fix(anthropic): keep enum and const as structured-output constraints (#7558)

* fix(anthropic): keep enum and const as structured-output constraints

The SDK's transformJSONSchema pops every keyword it recognises and
stringifies whatever is left into the node's description. It has no
branch for enum or const, so both were silently demoted from grammar
constraints into prose, leaving native structured outputs unenforced
for them on every Anthropic and Azure Anthropic agent block.

Lift enum and const out before the transform and re-attach them after,
so the transform's sanitising is preserved verbatim. Only lift the
shapes the API grammar-checks: a non-empty enum of primitives matching
the node's declared type, and a primitive const. Anything else stays
in place and is demoted exactly as before, since sending it would make
the API reject the whole request.

* chore(anthropic): type the structured-output test helper instead of any

Replaces the two Record<string, any> casts in the new test helper with a
WireSchemaNode interface describing the subset of the wire schema the
assertions read back, per the repo's no-any rule.

* test(anthropic): lock the structured-output schema non-mutation invariant

The builder deep-clones before walking so it never deletes enum/const from
the caller's schema object. Agent blocks inside a parallel or loop reuse the
same responseFormat object across iterations, so losing that clone would
strip the constraints from every iteration after the first. Verified the
test fails when the clone is removed.

Author: waleedlatif1

apps/sim/providers/anthropic/core.request.test.ts

@@ -303,3 +303,237 @@ describe('executeAnthropicProviderRequest forced tool use', () => {
     expect(warn).toHaveBeenCalledWith(expect.stringContaining('rejects forced tool_choice'))
   })
 })
+
+describe('executeAnthropicProviderRequest native structured outputs', () => {
+  /** The subset of the wire schema these assertions read back. */
+  interface WireSchemaNode {
+    type?: string | string[]
+    description?: string
+    format?: string
+    enum?: unknown[]
+    const?: unknown
+    minItems?: number
+    minimum?: number
+    additionalProperties?: boolean
+    required?: string[]
+    properties: Record<string, WireSchemaNode>
+    items: WireSchemaNode
+    anyOf: WireSchemaNode[]
+    $defs: Record<string, WireSchemaNode>
+  }
+
+  async function sendSchema(schema: Record<string, unknown>): Promise<WireSchemaNode> {
+    const create = vi.fn().mockResolvedValue({
+      id: 'msg-schema',
+      type: 'message',
+      role: 'assistant',
+      model: 'claude-sonnet-4-5',
+      content: [{ type: 'text', text: '{}' }],
+      stop_reason: 'end_turn',
+      stop_sequence: null,
+      usage: { input_tokens: 2, output_tokens: 2 },
+    })
+
+    await executeAnthropicProviderRequest(
+      {
+        model: 'claude-sonnet-4-5',
+        apiKey: 'test-key',
+        maxTokens: 1024,
+        messages: [{ role: 'user', content: 'Extract' }],
+        responseFormat: { name: 'extract', schema },
+      },
+      {
+        providerId: 'anthropic',
+        providerLabel: 'Anthropic',
+        createClient: () => ({ messages: { create } }) as never,
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+      }
+    )
+
+    const payload = create.mock.calls[0][0] as Anthropic.Messages.MessageCreateParams & {
+      output_config?: { format?: { type: string; schema: WireSchemaNode } }
+    }
+    return payload.output_config?.format?.schema as WireSchemaNode
+  }
+
+  beforeEach(() => {
+    mockExecuteTool.mockReset()
+  })
+
+  it('keeps enum and const as grammar constraints at every level', async () => {
+    const wireSchema = await sendSchema({
+      type: 'object',
+      additionalProperties: false,
+      required: ['kind', 'version', 'entities'],
+      properties: {
+        kind: { type: 'string', enum: ['person', 'org'] },
+        version: { type: 'string', const: 'v1' },
+        entities: {
+          type: 'array',
+          items: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['role'],
+            properties: {
+              role: {
+                type: 'string',
+                description: 'Which role applies.',
+                enum: ['owner', 'viewer'],
+              },
+            },
+          },
+        },
+      },
+    })
+
+    expect(wireSchema.properties.kind.enum).toEqual(['person', 'org'])
+    expect(wireSchema.properties.version.const).toBe('v1')
+    expect(wireSchema.properties.entities.items.properties.role.enum).toEqual(['owner', 'viewer'])
+  })
+
+  it('does not leave enum duplicated as description prose', async () => {
+    const wireSchema = await sendSchema({
+      type: 'object',
+      additionalProperties: false,
+      required: ['kind'],
+      properties: {
+        kind: { type: 'string', description: 'Which heading.', enum: ['goal', 'status'] },
+      },
+    })
+
+    expect(wireSchema.properties.kind.description).toBe('Which heading.')
+    expect(wireSchema.properties.kind.enum).toEqual(['goal', 'status'])
+  })
+
+  it('preserves enum inside $defs and anyOf branches', async () => {
+    const wireSchema = await sendSchema({
+      type: 'object',
+      additionalProperties: false,
+      required: ['status', 'choice'],
+      $defs: {
+        Status: { type: 'string', enum: ['open', 'closed'] },
+      },
+      properties: {
+        status: { $ref: '#/$defs/Status' },
+        choice: {
+          oneOf: [
+            { type: 'string', enum: ['a', 'b'] },
+            { type: 'string', const: 'c' },
+          ],
+        },
+      },
+    })
+
+    expect(wireSchema.$defs.Status.enum).toEqual(['open', 'closed'])
+    expect(wireSchema.properties.choice.anyOf[0].enum).toEqual(['a', 'b'])
+    expect(wireSchema.properties.choice.anyOf[1].const).toBe('c')
+  })
+
+  it('still sanitizes the constraints the API rejects', async () => {
+    const wireSchema = await sendSchema({
+      type: 'object',
+      required: ['tags', 'score', 'slug'],
+      properties: {
+        tags: { type: 'array', minItems: 5, items: { type: 'string', enum: ['x', 'y'] } },
+        score: { type: 'number', minimum: 1, maximum: 10 },
+        slug: { type: 'string', format: 'slug' },
+      },
+    })
+
+    expect(wireSchema.additionalProperties).toBe(false)
+    expect(wireSchema.properties.tags.minItems).toBeUndefined()
+    expect(wireSchema.properties.tags.items.enum).toEqual(['x', 'y'])
+    expect(wireSchema.properties.score.minimum).toBeUndefined()
+    expect(wireSchema.properties.score.description).toContain('minimum')
+    expect(wireSchema.properties.slug.format).toBeUndefined()
+  })
+
+  it.each<[string, Record<string, unknown>, 'enum' | 'const']>([
+    ['object enum members', { type: 'object', enum: [{ a: 1 }, { a: 2 }] }, 'enum'],
+    [
+      'array enum members',
+      { type: 'array', items: { type: 'string' }, enum: [['a'], ['b']] },
+      'enum',
+    ],
+    ['enum containing null on a string node', { type: 'string', enum: ['a', null] }, 'enum'],
+    ['mixed-type enum on a string node', { type: 'string', enum: ['a', 1] }, 'enum'],
+    ['string enum on a number node', { type: 'number', enum: ['a', 'b'] }, 'enum'],
+    ['empty enum', { type: 'string', enum: [] }, 'enum'],
+    ['enum on a node with no declared type', { anyOf: [{ type: 'string' }], enum: ['a'] }, 'enum'],
+    ['const with an object value', { type: 'object', const: { a: 1 } }, 'const'],
+    [
+      'const with an array value',
+      { type: 'array', items: { type: 'string' }, const: ['a'] },
+      'const',
+    ],
+  ])(
+    'leaves %s demoted into description, exactly as the SDK transform does today',
+    async (_name, node, keyword) => {
+      const wireSchema = await sendSchema({
+        type: 'object',
+        additionalProperties: false,
+        required: ['field'],
+        properties: { field: node as Record<string, unknown> },
+      })
+
+      expect(wireSchema.properties.field[keyword]).toBeUndefined()
+      expect(wireSchema.properties.field.description).toContain(`${keyword}:`)
+    }
+  )
+
+  it('lifts the primitive const and enum shapes the API does grammar-check', async () => {
+    const wireSchema = await sendSchema({
+      type: 'object',
+      additionalProperties: false,
+      required: ['count', 'flag', 'rank', 'nothing', 'fixed', 'zero', 'off'],
+      properties: {
+        count: { type: 'number', enum: [1, 2, 3] },
+        flag: { type: 'boolean', enum: [true, false] },
+        rank: { type: 'integer', enum: [1, 2] },
+        nothing: { type: 'null', enum: [null] },
+        fixed: { type: 'string', const: 'v1' },
+        zero: { type: 'number', const: 0 },
+        off: { type: 'boolean', const: false },
+      },
+    })
+
+    expect(wireSchema.properties.count.enum).toEqual([1, 2, 3])
+    expect(wireSchema.properties.flag.enum).toEqual([true, false])
+    expect(wireSchema.properties.rank.enum).toEqual([1, 2])
+    expect(wireSchema.properties.nothing.enum).toEqual([null])
+    expect(wireSchema.properties.fixed.const).toBe('v1')
+    expect(wireSchema.properties.zero.const).toBe(0)
+    expect(wireSchema.properties.off.const).toBe(false)
+  })
+
+  it("does not mutate the caller's schema, so parallel iterations reuse it safely", async () => {
+    const shared = {
+      type: 'object',
+      additionalProperties: false,
+      required: ['kind'],
+      properties: { kind: { type: 'string', enum: ['a', 'b'], description: 'd' } },
+    }
+    const before = JSON.stringify(shared)
+
+    const first = await sendSchema(shared)
+    const second = await sendSchema(shared)
+
+    expect(JSON.stringify(shared)).toBe(before)
+    expect(first.properties.kind.enum).toEqual(['a', 'b'])
+    expect(second.properties.kind.enum).toEqual(['a', 'b'])
+  })
+
+  it('does not mistake a property literally named enum for a keyword', async () => {
+    const wireSchema = await sendSchema({
+      type: 'object',
+      additionalProperties: false,
+      required: ['enum'],
+      properties: {
+        enum: { type: 'string', enum: ['left', 'right'] },
+      },
+    })
+
+    expect(wireSchema.properties.enum.type).toBe('string')
+    expect(wireSchema.properties.enum.enum).toEqual(['left', 'right'])
+  })
+})

apps/sim/providers/anthropic/core.ts

@@ -1,5 +1,4 @@
 import type Anthropic from '@anthropic-ai/sdk'
-import { transformJSONSchema } from '@anthropic-ai/sdk/lib/transform-json-schema'
 import type { RawMessageStreamEvent } from '@anthropic-ai/sdk/resources/messages/messages'
 import type { Logger } from '@sim/logger'
 import { getErrorMessage, toError } from '@sim/utils/errors'
@@ -8,6 +7,7 @@ import type { IterationToolCall, NormalizedBlockOutput, StreamingExecution } fro
 import { MAX_TOOL_ITERATIONS } from '@/providers'
 import { convertAnthropicRequestHistory } from '@/providers/anthropic/request-history'
 import { createAnthropicStreamingToolLoopStream } from '@/providers/anthropic/streaming-tool-loop'
+import { buildAnthropicStructuredOutputSchema } from '@/providers/anthropic/structured-output-schema'
 import {
   addAnthropicUsage,
   buildAnthropicUsageCost,
@@ -333,7 +333,7 @@ export async function executeAnthropicProviderRequest(
     const schema = request.responseFormat.schema || request.responseFormat
 
     if (useNativeStructuredOutputs) {
-      const transformedSchema = transformJSONSchema(schema)
+      const transformedSchema = buildAnthropicStructuredOutputSchema(schema)
       payload.output_config = {
         ...payload.output_config,
         format: {