// ❌ Anti-Pattern — trusting model output as typed data
// This crashes or corrupts data in production

const completion = await anthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  messages: [{ role: 'user', content: 'Return a JSON object with title and summary.' }],
  max_tokens: 512,
})

// Failure mode 1: Model wraps JSON in markdown code fences
// → "```json\n{\"title\":...}\n```"
// JSON.parse() throws on the backticks

// Failure mode 2: Context window pressure truncates mid-object
// → "{\"title\": \"Full-Stack AI\", \"summary\": \"This arti"
// Unclosed string → JSON.parse() throws

// Failure mode 3: Model hallucinates extra keys
// → {"title": "...", "summary": "...", "confidence": 0.95, "source": "gpt-4"}
// Extra keys silently accepted; "source" key pollutes domain model

// Failure mode 4: Type mismatch
// → {"title": "...", "summary": null}  // summary typed as string, arrives as null
// TypeScript types lie; runtime crash downstream

// Failure mode 5: Safety refusal in prose
// → "I can't help with that request because..."
// JSON.parse() throws; error swallowed; user sees 500

const data = JSON.parse(completion.content[0].text) as WorkspaceDocument
await db.documents.create(data) // Any of the above corrupts the database

// ✅ OpenAI Strict Structured Output — Layer 1 constraint
// file: src/gateway/StructuredOutputGateway.ts

import OpenAI from 'openai'
import { zodResponseFormat } from 'openai/helpers/zod'
import { z } from 'zod'

// The canonical Workspace Action schema — source of truth for the entire system
export const WorkspaceActionSchema = z.discriminatedUnion('type', [
  z.object({
    type: z.literal('canvas_node'),
    payload: z.object({
      id: z.string().uuid(),
      label: z.string().min(1).max(200),
      nodeType: z.enum(['component', 'service', 'database', 'queue']),
      position: z.object({ x: z.number(), y: z.number() }),
      metadata: z.record(z.string()).optional(),
    }),
  }),
  z.object({
    type: z.literal('text_reply'),
    payload: z.object({
      content: z.string().min(1),
      citations: z.array(z.string().uuid()).default([]),
    }),
  }),
  z.object({
    type: z.literal('tool_call'),
    payload: z.object({
      toolName: z.string(),
      args: z.record(z.unknown()),
    }),
  }),
]).and(
  z.object({
    confidence: z.number().min(0).max(1),
    reasoning: z.string().optional(),
  })
)

export type WorkspaceAction = z.infer<typeof WorkspaceActionSchema>

const openai = new OpenAI()

export async function getStructuredAction(
  messages: OpenAI.ChatCompletionMessageParam[],
): Promise<WorkspaceAction> {
  const completion = await openai.beta.chat.completions.parse({
    model: 'gpt-4o',
    messages,
    response_format: zodResponseFormat(WorkspaceActionSchema, 'workspace_action'),
  })

  const parsed = completion.choices[0].message.parsed
  if (!parsed) throw new Error('Model refused structured output')

  return parsed // Already validated by OpenAI SDK + Zod integration
}

// ✅ Anthropic structured output via forced tool use
// file: src/gateway/AnthropicStructuredGateway.ts

import Anthropic from '@anthropic-ai/sdk'
import { z } from 'zod'
import { zodToJsonSchema } from 'zod-to-json-schema'

const anthropic = new Anthropic()

export async function getAnthropicStructuredAction(
  messages: Anthropic.MessageParam[],
  systemPrompt: string,
): Promise<WorkspaceAction> {
  const jsonSchema = zodToJsonSchema(WorkspaceActionSchema, { name: 'workspace_action' })

  const response = await anthropic.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 2048,
    system: systemPrompt,
    messages,
    tools: [{
      name: 'workspace_action',
      description: 'Respond with a structured Workspace action',
      input_schema: jsonSchema.definitions?.workspace_action as Anthropic.Tool['input_schema'],
    }],
    tool_choice: { type: 'tool', name: 'workspace_action' }, // Force tool use
  })

  const toolUse = response.content.find((b): b is Anthropic.ToolUseBlock => b.type === 'tool_use')
  if (!toolUse) throw new Error('Model did not invoke workspace_action tool')

  // Layer 2 validation still required — provider does not guarantee Zod-level safety
  return WorkspaceActionSchema.parse(toolUse.input)
}

import { z } from 'zod'

// ❌ Permissive parse — extra keys pass through
const Permissive = z.object({ title: z.string() })
Permissive.parse({ title: 'Test', __injected: 'malicious' })
// → { title: 'Test', __injected: 'malicious' }  ← extra key survives

// ✅ Strict parse — extra keys are schema violations
const Strict = z.object({ title: z.string() }).strict()
Strict.parse({ title: 'Test', __injected: 'malicious' })
// → ZodError: Unrecognized key(s) in object: '__injected'

// ✅ One source of truth — types derived from Zod schemas
// file: packages/ai-schemas/src/workspace.ts

import { z } from 'zod'

// ── Primitive schemas (reusable) ────────────────────────────────────────────
export const UUIDSchema = z.string().uuid()
export const TimestampSchema = z.string().datetime({ offset: true })

// ── Canvas node schema ───────────────────────────────────────────────────────
export const CanvasNodeSchema = z.object({
  id: UUIDSchema,
  label: z.string().min(1).max(200),
  nodeType: z.enum(['component', 'service', 'database', 'queue', 'user', 'external']),
  position: z.object({
    x: z.number().finite(),
    y: z.number().finite(),
  }).strict(),
  metadata: z.record(z.string(), z.string()).optional(),
  createdAt: TimestampSchema,
  version: z.number().int().positive(),
}).strict() // No extra keys from model hallucinations

// Types are always inferred — never manually declared separately
export type CanvasNode = z.infer<typeof CanvasNodeSchema>

// ── Gateway action envelope ──────────────────────────────────────────────────
export const GatewayActionSchema = z.discriminatedUnion('type', [
  z.object({
    type: z.literal('canvas_node_create'),
    payload: CanvasNodeSchema.omit({ createdAt: true, version: true }),
  }).strict(),
  z.object({
    type: z.literal('text_reply'),
    payload: z.object({
      content: z.string().min(1),
      citations: z.array(UUIDSchema),
    }).strict(),
  }).strict(),
]).and(z.object({ confidence: z.number().min(0).max(1) }))

export type GatewayAction = z.infer<typeof GatewayActionSchema>

// Note: `z.discriminatedUnion()` does not support `.extend()` for fields shared
// across all variants. Use `.and(z.object({...}))` to intersect a common schema —
// this correctly requires `confidence` on all variant types while preserving
// discriminant-based narrowing (TypeScript narrows on `type` to the correct variant).

// ✅ AST self-repair for streaming JSON truncation
// file: src/gateway/JsonAstRepair.ts

/**
 * Attempts to repair a truncated JSON string by:
 * 1. Closing unclosed string literals (add missing closing quote)
 * 2. Closing unclosed arrays (add missing "]")
 * 3. Closing unclosed objects (add missing "}")
 * 4. Removing trailing commas before closing tokens
 */
export function repairTruncatedJson(partial: string): string {
  let s = partial.trimEnd()

  // Remove trailing partial key (e.g., `"la` at the end → remove entire partial key)
  s = s.replace(/,?\s*"[^"]*$/, '')

  // Remove trailing comma before closing
  s = s.replace(/,\s*$/, '')

  // Count unmatched structural characters
  let openBraces = 0
  let openBrackets = 0
  let inString = false
  let escaped = false

  for (const char of s) {
    if (escaped) { escaped = false; continue }
    if (char === '\\') { escaped = true; continue }
    if (char === '"') { inString = !inString; continue }
    if (inString) continue
    if (char === '{') openBraces++
    if (char === '}') openBraces--
    if (char === '[') openBrackets++
    if (char === ']') openBrackets--
  }

  // If we ended inside a string, close it
  if (inString) s += '"'

  // Close unmatched brackets and braces in reverse order
  s += ']'.repeat(Math.max(0, openBrackets))
  s += '}'.repeat(Math.max(0, openBraces))

  return s
}

export function safeParseWithRepair<T>(
  raw: string,
  schema: z.ZodType<T>,
): { success: true; data: T } | { success: false; error: string } {
  // Attempt 1: Direct parse — tryParse returns null on SyntaxError
  const directParsed = tryParse(raw)
  if (directParsed !== null) {
    const direct = schema.safeParse(directParsed)
    if (direct.success) return direct
  }

  // Attempt 2: Strip markdown code fences
  const stripped = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim()
  const directStripped = tryParseAndValidate(stripped, schema)
  if (directStripped.success) return directStripped

  // Attempt 3: AST repair
  const repaired = repairTruncatedJson(stripped)
  return tryParseAndValidate(repaired, schema)
}

function tryParse(s: string): unknown {
  try { return JSON.parse(s) } catch { return null }
}

function tryParseAndValidate<T>(
  s: string,
  schema: z.ZodType<T>,
): { success: true; data: T } | { success: false; error: string } {
  const parsed = tryParse(s)
  if (parsed === null) return { success: false, error: 'JSON parse failed' }
  const result = schema.safeParse(parsed)
  if (result.success) return { success: true, data: result.data }
  return { success: false, error: result.error.message }
}

// ✅ Complete schema gate — combines all three layers
// file: src/gateway/SchemaGate.ts

import { GatewayActionSchema, type GatewayAction } from '@workspace/ai-schemas'
import { safeParseWithRepair } from './JsonAstRepair'

export class SchemaGate {
  validate(raw: string): GatewayAction {
    const result = safeParseWithRepair(raw, GatewayActionSchema)

    if (result.success) {
      return result.data
    }

    // All three layers failed — surface a structured error, never swallow it
    throw new GatewaySchemaError(
      `Model output failed schema validation after repair attempt.\n` +
      `Raw output (truncated): ${raw.slice(0, 200)}\n` +
      `Validation error: ${result.error}`,
    )
  }
}

export class GatewaySchemaError extends Error {
  readonly name = 'GatewaySchemaError' as const
}