@@ -14,10 +14,15 @@ const ORG_OPS = [
   'get_aggregated_post_metrics',
 ]
 
-function jsonWand(toolId: string, field: string, example: string, placeholder: string) {
+function jsonWand(
+  toolId: string,
+  field: string,
+  example: string,
+  placeholder: string
+): NonNullable<SubBlockConfig['wandConfig']> {
   return {
     enabled: true,
-    generationType: 'json-object' as const,
+    generationType: example.trim().startsWith('[') ? 'json-array' : 'json-object',
     prompt: `Generate the Buffer ${field} input requested by the user. Follow this input contract: ${getToolMetadata(toolId)?.params[field]?.description ?? ''}. Example: ${example}. Use only resource IDs and URLs supplied by the user. Return ONLY the JSON.`,
     placeholder,
   }
@@ -663,12 +668,18 @@ export const BufferBlock: BlockConfig = {
             continue
           if (value === undefined || value === null || value === '') continue
           if ((key === 'mode' || key === 'schedulingType') && value === 'default') {
-            if (params.operation === 'create_post') {
-              result[key] = key === 'mode' ? 'addToQueue' : 'automatic'
-            }
+            result[key] =
+              params.operation === 'create_post'
+                ? key === 'mode'
+                  ? 'addToQueue'
+                  : 'automatic'
+                : undefined
+            continue
+          }
+          if (key === 'approvalChange' && value === 'default') {
+            result[key] = undefined
             continue
           }
-          if (key === 'approvalChange' && value === 'default') continue
           if (key === 'limit') {
             const limit = Number(value)
             if (Number.isFinite(limit)) result.limit = limit
 
@@ -1,6 +1,8 @@
 import '@sim/testing/mocks/executor'
 
 import { beforeEach, describe, expect, it, type Mock, vi } from 'vitest'
+import { executeBufferTool } from '@/lib/internal/buffer/execute-tool'
+import { BufferBlock } from '@/blocks/blocks/buffer'
 import { HarmonicBlock } from '@/blocks/blocks/harmonic'
 import { McpBlock } from '@/blocks/blocks/mcp'
 import { getBlock } from '@/blocks/index'
@@ -9,6 +11,8 @@ import type { ExecutionContext } from '@/executor/types'
 import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
 import type { SerializedBlock } from '@/serializer/types'
 import { executeTool } from '@/tools'
+import { bufferEditPostTool } from '@/tools/buffer/edit_post'
+import type { BufferEditPostParams } from '@/tools/buffer/types'
 import { mcpRunOperationTool } from '@/tools/mcp/run-operation'
 import type { ToolConfig } from '@/tools/types'
 import { getTool } from '@/tools/utils'
@@ -76,6 +80,50 @@ describe('GenericBlockHandler', () => {
     mockExecuteTool.mockResolvedValue({ success: true, output: { customResult: 'OK' } })
   })
 
+  it('preserves the current Buffer schedule and approval state when editing only text', async () => {
+    mockGetBlock.mockReturnValue(BufferBlock)
+    mockGetTool.mockReturnValue(bufferEditPostTool)
+    const providerInputs: Record<string, unknown>[] = []
+    vi.spyOn(globalThis, 'fetch').mockImplementation(async (_input, init) => {
+      const body: { variables: { input: Record<string, unknown> } } = JSON.parse(String(init?.body))
+      providerInputs.push(body.variables.input)
+      return Response.json({
+        data: { editPost: { __typename: 'PostActionSuccess', post: { id: 'post-1' } } },
+      })
+    })
+    mockExecuteTool.mockImplementation(async (toolId: string, params: BufferEditPostParams) => {
+      const response = await executeBufferTool({
+        toolId,
+        input: bufferEditPostTool.operation.input(params),
+        headers: new Headers(),
+        context: { workflowId: mockContext.workflowId, userId: 'user-1' },
+        requestId: 'request-1',
+      })
+      if (!bufferEditPostTool.transformResponse) throw new Error('Missing response transformer')
+      return bufferEditPostTool.transformResponse(response)
+    })
+
+    await handler.execute(
+      mockContext,
+      {
+        ...mockBlock,
+        metadata: { id: 'buffer', name: 'Buffer' },
+        config: { tool: 'buffer_edit_post', params: {} },
+      },
+      {
+        operation: 'edit_post',
+        apiKey: 'buffer-key',
+        postId: 'post-1',
+        text: 'Updated caption',
+        mode: 'default',
+        schedulingType: 'default',
+        approvalChange: 'default',
+      }
+    )
+
+    expect(providerInputs).toEqual([{ id: 'post-1', text: 'Updated caption' }])
+  })
+
   it('executes the standalone stable MCP action after argument resolution with trusted block scope', async () => {
     mockGetBlock.mockReturnValue(McpBlock)
     mockGetTool.mockReturnValue(mcpRunOperationTool)
 
@@ -67,6 +67,7 @@ function validateDueAt(
 export const bufferCreatePostInputSchema = z
   .object({
     ...sharedFields,
+    assets: sharedFields.assets.transform((assets) => assets ?? undefined),
     channelId: z.string().min(1, 'channelId is required'),
     mode: z.enum(['addToQueue', 'shareNext', 'shareNow', 'customScheduled']),
     schedulingType: z.enum(['automatic', 'notification']).default('automatic'),
 
@@ -12,6 +12,43 @@ import { executeBufferTool } from '@/lib/internal/buffer/execute-tool'
 import { createBufferPost } from '@/lib/internal/buffer/operations'
 
 describe('Buffer operations', () => {
+  it('creates a text post when optional assets are null', async () => {
+    const providerInputs: Record<string, unknown>[] = []
+    vi.spyOn(globalThis, 'fetch').mockImplementation(async (_input, init) => {
+      const body: { variables: { input: Record<string, unknown> } } = JSON.parse(String(init?.body))
+      providerInputs.push(body.variables.input)
+      return Response.json({
+        data: { createPost: { __typename: 'PostActionSuccess', post: { id: 'post-1' } } },
+      })
+    })
+
+    const response = await executeBufferTool({
+      toolId: 'buffer_create_post',
+      input: {
+        apiKey: 'buffer-key',
+        channelId: 'channel-1',
+        mode: 'addToQueue',
+        text: 'Caption',
+        assets: null,
+      },
+      headers: new Headers(),
+      context: { workflowId: 'workflow-1', userId: 'user-1' },
+      requestId: 'request-1',
+    })
+
+    expect(response.status).toBe(200)
+    expect(providerInputs).toEqual([
+      {
+        channelId: 'channel-1',
+        mode: 'addToQueue',
+        schedulingType: 'automatic',
+        text: 'Caption',
+        assets: [],
+        needsApproval: false,
+      },
+    ])
+  })
+
   it.each([
     { scheduling: {}, expected: {} },
     { scheduling: { mode: null, schedulingType: null }, expected: {} },
 
@@ -142,14 +142,15 @@ async function run() {
   if (process.env.BUFFER_CHANNEL_ID)
     assert(channel, 'BUFFER_CHANNEL_ID must identify an unlocked channel in this organization')
   if (!channel) {
-    await check('Get Posts from organization without channels', async () => {
+    await check('Get Posts with bounded draft pagination', async () => {
       const output = await tool('buffer_get_posts', {
         organizationId,
         limit: 1,
         filter: { status: ['draft'] },
         sort: [{ field: 'createdAt', direction: 'desc' }],
       })
-      assert.deepEqual(output.posts, [])
+      assert(Array.isArray(output.posts))
+      assert(output.posts.length <= 1)
       assert('hasPreviousPage' in toRecord(output.pageInfo))
     })
     await check('Aggregate metrics for an empty channel selection', async () => {
 
@@ -0,0 +1,32 @@
+import { toRecord } from '@sim/utils/object'
+import { describe, expect, it } from 'vitest'
+import { bufferGetPostsTool } from '@/tools/buffer/get_posts'
+
+describe('Buffer post ordering', () => {
+  it.each([
+    {
+      sort: [{ field: 'createdAt', direction: 'desc' }],
+      sortBy: 'unused-field',
+      sortDirection: 'asc',
+    },
+    {
+      sort: '[{"field":"createdAt","direction":"desc"}]',
+      sortBy: 'dueAt',
+      sortDirection: 'unused-direction',
+    },
+  ])('uses explicit ordering despite unused legacy values: $sortBy / $sortDirection', (sorting) => {
+    const body = bufferGetPostsTool.request.body
+    if (typeof body !== 'function') throw new Error('Missing post query builder')
+
+    const request = toRecord(
+      body({
+        apiKey: 'buffer-key',
+        organizationId: 'organization-1',
+        ...sorting,
+      })
+    )
+    const input = toRecord(toRecord(request.variables).input)
+
+    expect(input.sort).toEqual([{ field: 'createdAt', direction: 'desc' }])
+  })
+})
@@ -142,19 +142,19 @@ export const bufferGetPostsTool: ToolConfig<BufferGetPostsParams, BufferPostsRes
       }
       if (Object.keys(filter).length > 0) input.filter = filter
 
-      const sortBy = params.sortBy || 'dueAt'
-      if (!['dueAt', 'createdAt'].includes(sortBy)) {
-        throw new Error('sortBy must be either "dueAt" or "createdAt"')
-      }
-      const sortDirection = params.sortDirection || 'asc'
-      if (!['asc', 'desc'].includes(sortDirection)) {
-        throw new Error('sortDirection must be either "asc" or "desc"')
+      if (params.sort) {
+        input.sort = typeof params.sort === 'string' ? JSON.parse(params.sort) : params.sort
+      } else {
+        const sortBy = params.sortBy || 'dueAt'
+        if (!['dueAt', 'createdAt'].includes(sortBy)) {
+          throw new Error('sortBy must be either "dueAt" or "createdAt"')
+        }
+        const sortDirection = params.sortDirection || 'asc'
+        if (!['asc', 'desc'].includes(sortDirection)) {
+          throw new Error('sortDirection must be either "asc" or "desc"')
+        }
+        input.sort = [{ field: sortBy, direction: sortDirection }]
       }
-      input.sort = params.sort
-        ? typeof params.sort === 'string'
-          ? JSON.parse(params.sort)
-          : params.sort
-        : [{ field: sortBy, direction: sortDirection }]
 
       return {
         query: GET_POSTS_QUERY,