@lov3kaizen/agentsea-structured 0.5.1

package/dist/index.js

@@ -0,0 +1,3210 @@
+import { z } from 'zod';
+import { zodToJsonSchema as zodToJsonSchema$1 } from 'zod-to-json-schema';
+import { EventEmitter } from 'eventemitter3';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function zodToJsonSchema(schema) {
+  return zodToJsonSchema$1(schema, { $refStrategy: "none" });
+}
+function schemaToPrompt(schema, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  switch (opts.format) {
+    case "json-schema":
+      return generateJsonSchemaPrompt(schema, opts);
+    case "typescript":
+      return generateTypeScriptPrompt(schema, opts);
+    case "natural":
+      return generateNaturalPrompt(schema, opts);
+    case "examples":
+      return generateExamplesPrompt(schema, opts);
+    default:
+      return generateJsonSchemaPrompt(schema, opts);
+  }
+}
+function generateJsonSchemaPrompt(schema, opts) {
+  const jsonSchema = zodToJsonSchema$1(schema, {
+    $refStrategy: "none",
+    errorMessages: true
+  });
+  const cleanedSchema = cleanJsonSchema(jsonSchema);
+  const text = [
+    "Respond with a JSON object that matches this schema:",
+    "",
+    "```json",
+    JSON.stringify(cleanedSchema, null, opts.indent),
+    "```"
+  ].join("\n");
+  return {
+    text,
+    format: "json-schema",
+    jsonSchema: cleanedSchema
+  };
+}
+function generateTypeScriptPrompt(schema, opts) {
+  const typeScript = zodToTypeScript(schema, opts);
+  const jsonSchema = zodToJsonSchema$1(schema, {
+    $refStrategy: "none"
+  });
+  const text = [
+    "Respond with a JSON object matching this TypeScript type:",
+    "",
+    "```typescript",
+    typeScript,
+    "```"
+  ].join("\n");
+  return {
+    text,
+    format: "typescript",
+    jsonSchema,
+    typeScript
+  };
+}
+function generateNaturalPrompt(schema, opts) {
+  const fieldInfos = analyzeSchema(schema, opts);
+  const jsonSchema = zodToJsonSchema$1(schema, {
+    $refStrategy: "none"
+  });
+  const lines = [
+    "Respond with a JSON object containing the following fields:",
+    ""
+  ];
+  for (const field of fieldInfos) {
+    const requiredStr = field.required ? "(required)" : "(optional)";
+    let line = `- ${field.name} ${requiredStr}: ${field.jsonType}`;
+    if (opts.includeDescriptions && field.description) {
+      line += ` - ${field.description}`;
+    }
+    if (opts.includeConstraints && field.constraints.length > 0) {
+      const constraintStrs = field.constraints.map((c) => c.description);
+      line += ` [${constraintStrs.join(", ")}]`;
+    }
+    lines.push(line);
+    if (field.children && field.children.length > 0) {
+      for (const child of field.children) {
+        lines.push(`  - ${child.name}: ${child.jsonType}`);
+      }
+    }
+  }
+  return {
+    text: lines.join("\n"),
+    format: "natural",
+    jsonSchema
+  };
+}
+function generateExamplesPrompt(schema, opts) {
+  const jsonSchema = zodToJsonSchema$1(schema, {
+    $refStrategy: "none"
+  });
+  const example = generateExample(jsonSchema, opts.maxDepth);
+  const text = [
+    "Respond with a JSON object following this example structure:",
+    "",
+    "```json",
+    JSON.stringify(example, null, opts.indent),
+    "```"
+  ].join("\n");
+  return {
+    text,
+    format: "examples",
+    jsonSchema
+  };
+}
+function cleanJsonSchema(schema) {
+  const cleaned = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key.startsWith("$") && key !== "$defs") continue;
+    if (key === "additionalProperties" && value === false) continue;
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      cleaned[key] = cleanJsonSchema(value);
+    } else if (Array.isArray(value)) {
+      cleaned[key] = value.map(
+        (item) => typeof item === "object" && item !== null ? cleanJsonSchema(item) : item
+      );
+    } else {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}
+function zodToTypeScript(schema, opts, depth = 0) {
+  if (depth > opts.maxDepth) return "any";
+  const indent = "  ".repeat(depth);
+  const innerIndent = "  ".repeat(depth + 1);
+  if (schema instanceof z.ZodObject) {
+    const shape = schema.shape;
+    const lines = ["{"];
+    for (const [key, value] of Object.entries(shape)) {
+      const fieldSchema = value;
+      const isOptional = fieldSchema.isOptional?.() ?? false;
+      const typeStr = zodToTypeScript(fieldSchema, opts, depth + 1);
+      const optionalMarker = isOptional ? "?" : "";
+      const description = fieldSchema.description;
+      const descComment = opts.includeDescriptions && description ? ` // ${description}` : "";
+      lines.push(
+        `${innerIndent}${key}${optionalMarker}: ${typeStr};${descComment}`
+      );
+    }
+    lines.push(`${indent}}`);
+    return lines.join("\n");
+  }
+  if (schema instanceof z.ZodArray) {
+    const elementType = zodToTypeScript(schema.element, opts, depth);
+    return `${elementType}[]`;
+  }
+  if (schema instanceof z.ZodString) {
+    return "string";
+  }
+  if (schema instanceof z.ZodNumber) {
+    return "number";
+  }
+  if (schema instanceof z.ZodBoolean) {
+    return "boolean";
+  }
+  if (schema instanceof z.ZodNull) {
+    return "null";
+  }
+  if (schema instanceof z.ZodUndefined) {
+    return "undefined";
+  }
+  if (schema instanceof z.ZodLiteral) {
+    const value = schema.value;
+    return typeof value === "string" ? `'${value}'` : String(value);
+  }
+  if (schema instanceof z.ZodEnum) {
+    const values = schema.options;
+    return values.map((v) => `'${v}'`).join(" | ");
+  }
+  if (schema instanceof z.ZodNativeEnum) {
+    return "enum";
+  }
+  if (schema instanceof z.ZodUnion) {
+    const options = schema.options;
+    return options.map((o) => zodToTypeScript(o, opts, depth)).join(" | ");
+  }
+  if (schema instanceof z.ZodOptional) {
+    const innerType = zodToTypeScript(schema.unwrap(), opts, depth);
+    return `${innerType} | undefined`;
+  }
+  if (schema instanceof z.ZodNullable) {
+    const innerType = zodToTypeScript(schema.unwrap(), opts, depth);
+    return `${innerType} | null`;
+  }
+  if (schema instanceof z.ZodDefault) {
+    return zodToTypeScript(schema.removeDefault(), opts, depth);
+  }
+  if (schema instanceof z.ZodRecord) {
+    const valueType = zodToTypeScript(schema.valueSchema, opts, depth);
+    return `Record<string, ${valueType}>`;
+  }
+  if (schema instanceof z.ZodTuple) {
+    const items = schema.items;
+    const types = items.map((item) => zodToTypeScript(item, opts, depth));
+    return `[${types.join(", ")}]`;
+  }
+  if (schema instanceof z.ZodDate) {
+    return "Date";
+  }
+  return "unknown";
+}
+function analyzeSchema(schema, opts, path = "") {
+  const fields = [];
+  if (schema instanceof z.ZodObject) {
+    const shape = schema.shape;
+    for (const [key, value] of Object.entries(shape)) {
+      const fieldSchema = value;
+      const fieldPath = path ? `${path}.${key}` : key;
+      const info = extractFieldInfo(key, fieldSchema, fieldPath, opts);
+      fields.push(info);
+    }
+  }
+  return fields;
+}
+function extractFieldInfo(name, schema, path, opts) {
+  const constraints = extractConstraints(schema);
+  const { zodType, jsonType } = getTypeNames(schema);
+  const description = schema.description;
+  const isOptional = schema.isOptional?.() ?? false;
+  const hasDefault = schema instanceof z.ZodDefault;
+  const defaultValue = hasDefault ? schema._def.defaultValue() : void 0;
+  let children;
+  const unwrapped = unwrapSchema(schema);
+  if (unwrapped instanceof z.ZodObject) {
+    children = analyzeSchema(unwrapped, opts, path);
+  }
+  return {
+    path,
+    name,
+    zodType,
+    jsonType,
+    description,
+    required: !isOptional,
+    hasDefault,
+    defaultValue,
+    constraints,
+    children
+  };
+}
+function extractConstraints(schema) {
+  const constraints = [];
+  const def = schema._def;
+  const checks = def?.checks ?? [];
+  for (const check of checks) {
+    switch (check.kind) {
+      case "min":
+        constraints.push({
+          type: "min",
+          value: check.value,
+          description: `minimum: ${String(check.value)}`
+        });
+        break;
+      case "max":
+        constraints.push({
+          type: "max",
+          value: check.value,
+          description: `maximum: ${String(check.value)}`
+        });
+        break;
+      case "length":
+        constraints.push({
+          type: "length",
+          value: check.value,
+          description: `length: ${String(check.value)}`
+        });
+        break;
+      case "email":
+        constraints.push({
+          type: "email",
+          value: true,
+          description: "must be valid email"
+        });
+        break;
+      case "url":
+        constraints.push({
+          type: "url",
+          value: true,
+          description: "must be valid URL"
+        });
+        break;
+      case "regex":
+        constraints.push({
+          type: "regex",
+          value: check.value,
+          description: `must match pattern`
+        });
+        break;
+      case "int":
+        constraints.push({
+          type: "int",
+          value: true,
+          description: "must be integer"
+        });
+        break;
+      case "positive":
+        constraints.push({
+          type: "positive",
+          value: true,
+          description: "must be positive"
+        });
+        break;
+      case "negative":
+        constraints.push({
+          type: "negative",
+          value: true,
+          description: "must be negative"
+        });
+        break;
+    }
+  }
+  return constraints;
+}
+function getTypeNames(schema) {
+  const unwrapped = unwrapSchema(schema);
+  if (unwrapped instanceof z.ZodString)
+    return { zodType: "ZodString", jsonType: "string" };
+  if (unwrapped instanceof z.ZodNumber)
+    return { zodType: "ZodNumber", jsonType: "number" };
+  if (unwrapped instanceof z.ZodBoolean)
+    return { zodType: "ZodBoolean", jsonType: "boolean" };
+  if (unwrapped instanceof z.ZodNull)
+    return { zodType: "ZodNull", jsonType: "null" };
+  if (unwrapped instanceof z.ZodArray)
+    return { zodType: "ZodArray", jsonType: "array" };
+  if (unwrapped instanceof z.ZodObject)
+    return { zodType: "ZodObject", jsonType: "object" };
+  if (unwrapped instanceof z.ZodEnum)
+    return { zodType: "ZodEnum", jsonType: "string" };
+  if (unwrapped instanceof z.ZodLiteral) {
+    const value = unwrapped.value;
+    const type = typeof value;
+    return { zodType: "ZodLiteral", jsonType: type };
+  }
+  if (unwrapped instanceof z.ZodUnion)
+    return { zodType: "ZodUnion", jsonType: "union" };
+  if (unwrapped instanceof z.ZodRecord)
+    return { zodType: "ZodRecord", jsonType: "object" };
+  if (unwrapped instanceof z.ZodDate)
+    return { zodType: "ZodDate", jsonType: "string" };
+  return { zodType: "unknown", jsonType: "unknown" };
+}
+function unwrapSchema(schema) {
+  if (schema instanceof z.ZodOptional) return unwrapSchema(schema.unwrap());
+  if (schema instanceof z.ZodNullable) return unwrapSchema(schema.unwrap());
+  if (schema instanceof z.ZodDefault)
+    return unwrapSchema(schema.removeDefault());
+  return schema;
+}
+function generateExample(schema, maxDepth, depth = 0) {
+  if (depth > maxDepth) return null;
+  if (schema.examples && schema.examples.length > 0) {
+    return schema.examples[0];
+  }
+  if (schema.default !== void 0) {
+    return schema.default;
+  }
+  if (schema.const !== void 0) {
+    return schema.const;
+  }
+  if (schema.enum && schema.enum.length > 0) {
+    return schema.enum[0];
+  }
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  switch (type) {
+    case "string":
+      return schema.format === "email" ? "example@email.com" : schema.format === "uri" ? "https://example.com" : "string";
+    case "number":
+    case "integer":
+      return schema.minimum ?? 0;
+    case "boolean":
+      return true;
+    case "null":
+      return null;
+    case "array":
+      if (schema.items) {
+        const itemExample = generateExample(
+          Array.isArray(schema.items) ? schema.items[0] : schema.items,
+          maxDepth,
+          depth + 1
+        );
+        return [itemExample];
+      }
+      return [];
+    case "object":
+      if (schema.properties) {
+        const obj = {};
+        for (const [key, propSchema] of Object.entries(schema.properties)) {
+          obj[key] = generateExample(propSchema, maxDepth, depth + 1);
+        }
+        return obj;
+      }
+      return {};
+    default:
+      if (schema.anyOf && schema.anyOf.length > 0) {
+        return generateExample(schema.anyOf[0], maxDepth, depth);
+      }
+      if (schema.oneOf && schema.oneOf.length > 0) {
+        return generateExample(schema.oneOf[0], maxDepth, depth);
+      }
+      return null;
+  }
+}
+var DEFAULT_OPTIONS, SchemaPromptGenerator;
+var init_SchemaToPrompt = __esm({
+  "src/schema/SchemaToPrompt.ts"() {
+    DEFAULT_OPTIONS = {
+      format: "json-schema",
+      includeDescriptions: true,
+      includeExamples: true,
+      includeConstraints: true,
+      maxDepth: 10,
+      indent: 2
+    };
+    SchemaPromptGenerator = {
+      toJsonSchema: (schema, options) => schemaToPrompt(schema, { ...options, format: "json-schema" }),
+      toTypeScript: (schema, options) => schemaToPrompt(schema, { ...options, format: "typescript" }),
+      toNatural: (schema, options) => schemaToPrompt(schema, { ...options, format: "natural" }),
+      toExamples: (schema, options) => schemaToPrompt(schema, { ...options, format: "examples" }),
+      generateExample
+    };
+  }
+});
+function validateSchema(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+  return {
+    success: false,
+    errors: formatZodErrors(result.error)
+  };
+}
+function validateSchemaOrThrow(schema, data) {
+  return schema.parse(data);
+}
+function validatePartial(schema, data, options = {}) {
+  const partialSchema = makePartial(schema);
+  const result = partialSchema.safeParse(data);
+  if (!result.success) {
+    return {
+      success: false,
+      errors: formatZodErrors(result.error)
+    };
+  }
+  if (options.requiredFields && options.requiredFields.length > 0) {
+    const missingFields = [];
+    for (const field of options.requiredFields) {
+      const value = getNestedValue(result.data, field);
+      if (value === void 0) {
+        missingFields.push({
+          path: field.split("."),
+          message: `Required field '${field}' is missing`,
+          expected: "value",
+          received: void 0,
+          code: "custom"
+        });
+      }
+    }
+    if (missingFields.length > 0) {
+      return {
+        success: false,
+        errors: missingFields
+      };
+    }
+  }
+  return {
+    success: true,
+    data: result.data
+  };
+}
+function matchesSchema(schema, data) {
+  return schema.safeParse(data).success;
+}
+function coerceToSchema(schema, data) {
+  const directResult = schema.safeParse(data);
+  if (directResult.success) {
+    return { success: true, data: directResult.data };
+  }
+  const coerced = coerceData(data, schema);
+  const coercedResult = schema.safeParse(coerced);
+  if (coercedResult.success) {
+    return { success: true, data: coercedResult.data };
+  }
+  return {
+    success: false,
+    errors: formatZodErrors(coercedResult.error)
+  };
+}
+function getValidationHints(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return [];
+  }
+  return result.error.issues.map((issue) => generateHint(issue));
+}
+function formatZodErrors(error) {
+  return error.issues.map((issue) => ({
+    path: issue.path.map((p) => typeof p === "number" ? p : String(p)),
+    message: issue.message,
+    expected: getExpectedFromIssue(issue),
+    received: getReceivedFromIssue(issue),
+    code: issue.code
+  }));
+}
+function makePartial(schema) {
+  if (schema instanceof z.ZodObject) {
+    return schema.partial();
+  }
+  if (schema instanceof z.ZodArray) {
+    return z.array(makePartial(schema.element));
+  }
+  if (schema instanceof z.ZodUnion) {
+    return z.union(
+      schema.options.map((opt) => makePartial(opt))
+    );
+  }
+  if (schema instanceof z.ZodIntersection) {
+    return z.intersection(
+      makePartial(schema._def.left),
+      makePartial(schema._def.right)
+    );
+  }
+  return schema.optional();
+}
+function getNestedValue(obj, path) {
+  if (typeof obj !== "object" || obj === null) {
+    return void 0;
+  }
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (typeof current !== "object" || current === null) {
+      return void 0;
+    }
+    const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
+    if (arrayMatch) {
+      const [, key, index] = arrayMatch;
+      const arr = current[key];
+      if (!Array.isArray(arr)) {
+        return void 0;
+      }
+      current = arr[parseInt(index, 10)];
+    } else {
+      current = current[part];
+    }
+  }
+  return current;
+}
+function coerceData(data, schema) {
+  if (schema instanceof z.ZodString && typeof data === "number") {
+    return String(data);
+  }
+  if (schema instanceof z.ZodNumber && typeof data === "string") {
+    const num = Number(data);
+    if (!isNaN(num)) {
+      return num;
+    }
+  }
+  if (schema instanceof z.ZodBoolean) {
+    if (data === "true" || data === 1) return true;
+    if (data === "false" || data === 0) return false;
+  }
+  if (schema instanceof z.ZodArray && typeof data === "string") {
+    try {
+      const parsed = JSON.parse(data);
+      if (Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  if (schema instanceof z.ZodObject && typeof data === "string") {
+    try {
+      return JSON.parse(data);
+    } catch {
+    }
+  }
+  if (schema instanceof z.ZodObject && typeof data === "object" && data !== null) {
+    const objSchema = schema;
+    const shape = objSchema.shape;
+    const result = {
+      ...data
+    };
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      if (key in result) {
+        result[key] = coerceData(result[key], fieldSchema);
+      }
+    }
+    return result;
+  }
+  return data;
+}
+function generateHint(issue, _data) {
+  const path = issue.path.join(".");
+  const pathPrefix = path ? `At '${path}': ` : "";
+  switch (issue.code) {
+    case "invalid_type":
+      return `${pathPrefix}Expected ${issue.expected}, but received ${issue.received}. Please provide a value of type ${issue.expected}.`;
+    case "invalid_literal":
+      return `${pathPrefix}Expected the exact value ${JSON.stringify(issue.expected)}, but received ${JSON.stringify(issue.received)}.`;
+    case "unrecognized_keys":
+      return `${pathPrefix}Unexpected keys: ${issue.keys.join(", ")}. Remove these keys or check the schema.`;
+    case "invalid_union":
+      return `${pathPrefix}Value doesn't match any of the allowed types. Check the schema for valid options.`;
+    case "invalid_enum_value":
+      return `${pathPrefix}Value must be one of: ${issue.options.join(", ")}`;
+    case "invalid_string":
+      if ("validation" in issue) {
+        const validation = issue.validation;
+        if (typeof validation === "string") {
+          return `${pathPrefix}String must be a valid ${validation}.`;
+        }
+      }
+      return `${pathPrefix}Invalid string format.`;
+    case "too_small": {
+      const smallIssue = issue;
+      if (smallIssue.type === "string") {
+        return `${pathPrefix}String must be at least ${smallIssue.minimum} characters.`;
+      }
+      if (smallIssue.type === "number") {
+        return `${pathPrefix}Number must be ${smallIssue.inclusive ? "at least" : "greater than"} ${smallIssue.minimum}.`;
+      }
+      if (smallIssue.type === "array") {
+        return `${pathPrefix}Array must have at least ${smallIssue.minimum} items.`;
+      }
+      return `${pathPrefix}Value is too small.`;
+    }
+    case "too_big": {
+      const bigIssue = issue;
+      if (bigIssue.type === "string") {
+        return `${pathPrefix}String must be at most ${bigIssue.maximum} characters.`;
+      }
+      if (bigIssue.type === "number") {
+        return `${pathPrefix}Number must be ${bigIssue.inclusive ? "at most" : "less than"} ${bigIssue.maximum}.`;
+      }
+      if (bigIssue.type === "array") {
+        return `${pathPrefix}Array must have at most ${bigIssue.maximum} items.`;
+      }
+      return `${pathPrefix}Value is too big.`;
+    }
+    case "custom":
+      return `${pathPrefix}${issue.message}`;
+    case "invalid_date":
+      return `${pathPrefix}Invalid date value. Provide a valid date string or Date object.`;
+    default:
+      return `${pathPrefix}${issue.message}`;
+  }
+}
+function getExpectedFromIssue(issue) {
+  if ("expected" in issue) {
+    return String(issue.expected);
+  }
+  return void 0;
+}
+function getReceivedFromIssue(issue) {
+  if ("received" in issue) {
+    return issue.received;
+  }
+  return void 0;
+}
+var SchemaValidator;
+var init_SchemaValidator = __esm({
+  "src/schema/SchemaValidator.ts"() {
+    SchemaValidator = {
+      validate: validateSchema,
+      validateOrThrow: validateSchemaOrThrow,
+      validatePartial,
+      matches: matchesSchema,
+      coerce: coerceToSchema,
+      getHints: getValidationHints,
+      formatErrors: formatZodErrors
+    };
+  }
+});
+
+// src/streaming/IncrementalJsonParser.ts
+function processEscapeChar(char) {
+  switch (char) {
+    case "n":
+      return "\n";
+    case "r":
+      return "\r";
+    case "t":
+      return "	";
+    case "\\":
+      return "\\";
+    case '"':
+      return '"';
+    case "/":
+      return "/";
+    case "b":
+      return "\b";
+    case "f":
+      return "\f";
+    default:
+      return char;
+  }
+}
+function tokenizeJson(json) {
+  const tokens = [];
+  const path = [];
+  let inString = false;
+  let inEscape = false;
+  let currentString = "";
+  let currentKey = null;
+  for (let i = 0; i < json.length; i++) {
+    const char = json[i];
+    if (inString) {
+      if (inEscape) {
+        currentString += processEscapeChar(char);
+        inEscape = false;
+      } else if (char === "\\") {
+        inEscape = true;
+      } else if (char === '"') {
+        inString = false;
+        tokens.push({
+          type: currentKey === null ? "key" : "string",
+          value: currentString,
+          path: [...path],
+          complete: true
+        });
+        if (currentKey === null) {
+          currentKey = currentString;
+        }
+        currentString = "";
+      } else {
+        currentString += char;
+      }
+    } else if (/\s/.test(char)) {
+      continue;
+    } else if (char === "{") {
+      tokens.push({
+        type: "object_start",
+        value: "{",
+        path: [...path],
+        complete: true
+      });
+    } else if (char === "}") {
+      tokens.push({
+        type: "object_end",
+        value: "}",
+        path: [...path],
+        complete: true
+      });
+      path.pop();
+      currentKey = null;
+    } else if (char === "[") {
+      tokens.push({
+        type: "array_start",
+        value: "[",
+        path: [...path],
+        complete: true
+      });
+    } else if (char === "]") {
+      tokens.push({
+        type: "array_end",
+        value: "]",
+        path: [...path],
+        complete: true
+      });
+    } else if (char === ":") {
+      tokens.push({
+        type: "colon",
+        value: ":",
+        path: [...path],
+        complete: true
+      });
+      if (currentKey) {
+        path.push(currentKey);
+      }
+    } else if (char === ",") {
+      tokens.push({
+        type: "comma",
+        value: ",",
+        path: [...path],
+        complete: true
+      });
+      path.pop();
+      currentKey = null;
+    } else if (char === '"') {
+      inString = true;
+      currentString = "";
+    }
+  }
+  return tokens;
+}
+var IncrementalJsonParser;
+var init_IncrementalJsonParser = __esm({
+  "src/streaming/IncrementalJsonParser.ts"() {
+    IncrementalJsonParser = class {
+      state;
+      result;
+      pendingUpdates;
+      constructor() {
+        this.state = this.createInitialState();
+        this.result = {};
+        this.pendingUpdates = [];
+      }
+      /**
+       * Feed a chunk of text to the parser
+       */
+      feed(chunk) {
+        this.pendingUpdates = [];
+        this.state.buffer += chunk;
+        this.parse();
+        return this.pendingUpdates;
+      }
+      /**
+       * Get the current parsed result
+       */
+      getResult() {
+        this.finalize();
+        return this.result;
+      }
+      /**
+       * Reset the parser state
+       */
+      reset() {
+        this.state = this.createInitialState();
+        this.result = {};
+        this.pendingUpdates = [];
+      }
+      /**
+       * Create initial parser state
+       */
+      createInitialState() {
+        return {
+          currentPath: [],
+          depth: 0,
+          buffer: "",
+          partial: {},
+          inString: false,
+          inEscape: false,
+          currentString: "",
+          currentKey: null,
+          containerStack: []
+        };
+      }
+      /**
+       * Parse the current buffer
+       */
+      parse() {
+        let i = 0;
+        let lastSuccessfulIndex = -1;
+        while (i < this.state.buffer.length) {
+          const char = this.state.buffer[i];
+          if (this.state.inString) {
+            i = this.parseStringChar(i, char);
+            lastSuccessfulIndex = i;
+          } else {
+            if (char === "t" || char === "f" || char === "n") {
+              const remaining = this.state.buffer.slice(i);
+              const isComplete = remaining.startsWith("true") || remaining.startsWith("false") || remaining.startsWith("null");
+              if (!isComplete) {
+                break;
+              }
+            }
+            if (/[-\d]/.test(char)) {
+              const remaining = this.state.buffer.slice(i);
+              const match = remaining.match(/^-?\d+(\.\d+)?([eE][+-]?\d+)?/);
+              if (match) {
+                const numStr = match[0];
+                const afterNum = remaining.slice(numStr.length);
+                if (afterNum.length === 0 || afterNum.length > 0 && !/[\s,}\]]/.test(afterNum[0])) {
+                  break;
+                }
+              }
+            }
+            i = this.parseChar(i, char);
+            lastSuccessfulIndex = i;
+          }
+          i++;
+        }
+        if (lastSuccessfulIndex >= 0) {
+          this.state.buffer = this.state.buffer.slice(lastSuccessfulIndex + 1);
+        }
+      }
+      /**
+       * Parse a character inside a string
+       */
+      parseStringChar(index, char) {
+        if (this.state.inEscape) {
+          this.state.currentString += this.processEscape(char);
+          this.state.inEscape = false;
+          return index;
+        }
+        if (char === "\\") {
+          this.state.inEscape = true;
+          return index;
+        }
+        if (char === '"') {
+          this.state.inString = false;
+          this.handleStringComplete();
+          return index;
+        }
+        this.state.currentString += char;
+        return index;
+      }
+      /**
+       * Parse a character outside a string
+       */
+      parseChar(index, char) {
+        if (/\s/.test(char)) {
+          return index;
+        }
+        switch (char) {
+          case "{":
+            this.handleObjectStart();
+            break;
+          case "}":
+            this.handleObjectEnd();
+            break;
+          case "[":
+            this.handleArrayStart();
+            break;
+          case "]":
+            this.handleArrayEnd();
+            break;
+          case '"':
+            this.state.inString = true;
+            this.state.currentString = "";
+            break;
+          case ":":
+            break;
+          case ",":
+            if (this.getCurrentContainer() === "object") {
+              this.state.currentKey = null;
+            } else if (this.getCurrentContainer() === "array") {
+              const lastPath = this.state.currentPath[this.state.currentPath.length - 1];
+              if (typeof lastPath === "string" && /^\d+$/.test(lastPath)) {
+                this.state.currentPath[this.state.currentPath.length - 1] = String(
+                  parseInt(lastPath, 10) + 1
+                );
+              }
+            }
+            break;
+          case "t":
+          case "f":
+            index = this.parseBoolean(index);
+            break;
+          case "n":
+            index = this.parseNull(index);
+            break;
+          default:
+            if (/[-\d]/.test(char)) {
+              index = this.parseNumber(index);
+            }
+        }
+        return index;
+      }
+      /**
+       * Process an escape character
+       */
+      processEscape(char) {
+        switch (char) {
+          case "n":
+            return "\n";
+          case "r":
+            return "\r";
+          case "t":
+            return "	";
+          case "\\":
+            return "\\";
+          case '"':
+            return '"';
+          case "/":
+            return "/";
+          default:
+            return char;
+        }
+      }
+      /**
+       * Handle completion of a string
+       */
+      handleStringComplete() {
+        const value = this.state.currentString;
+        if (this.getCurrentContainer() === "object" && this.state.currentKey === null) {
+          this.state.currentKey = value;
+        } else {
+          this.setValue(value);
+        }
+      }
+      /**
+       * Handle start of object
+       */
+      handleObjectStart() {
+        this.state.depth++;
+        this.state.containerStack.push("object");
+        if (this.state.currentKey !== null) {
+          this.state.currentPath.push(this.state.currentKey);
+          this.state.currentKey = null;
+        }
+        this.setNestedValue(this.result, this.state.currentPath, {});
+      }
+      /**
+       * Handle end of object
+       */
+      handleObjectEnd() {
+        this.state.depth--;
+        this.state.containerStack.pop();
+        const path = [...this.state.currentPath];
+        const value = this.getNestedValue(this.result, path);
+        this.pendingUpdates.push({
+          path,
+          value,
+          complete: true
+        });
+        const currentContainer = this.getCurrentContainer();
+        if (currentContainer !== "array" && this.state.currentPath.length > 0) {
+          this.state.currentPath.pop();
+        }
+      }
+      /**
+       * Handle start of array
+       */
+      handleArrayStart() {
+        this.state.depth++;
+        this.state.containerStack.push("array");
+        if (this.state.currentKey !== null) {
+          this.state.currentPath.push(this.state.currentKey);
+          this.state.currentKey = null;
+        }
+        this.setNestedValue(this.result, this.state.currentPath, []);
+        this.state.currentPath.push("0");
+      }
+      /**
+       * Handle end of array
+       */
+      handleArrayEnd() {
+        this.state.depth--;
+        this.state.containerStack.pop();
+        this.state.currentPath.pop();
+        const path = [...this.state.currentPath];
+        const value = this.getNestedValue(this.result, path);
+        this.pendingUpdates.push({
+          path,
+          value,
+          complete: true
+        });
+        const currentContainer = this.getCurrentContainer();
+        if (currentContainer !== "array" && this.state.currentPath.length > 0) {
+          this.state.currentPath.pop();
+        }
+      }
+      /**
+       * Parse a boolean value
+       */
+      parseBoolean(startIndex) {
+        const remaining = this.state.buffer.slice(startIndex);
+        if (remaining.startsWith("true")) {
+          this.setValue(true);
+          return startIndex + 3;
+        }
+        if (remaining.startsWith("false")) {
+          this.setValue(false);
+          return startIndex + 4;
+        }
+        return startIndex;
+      }
+      /**
+       * Parse a null value
+       */
+      parseNull(startIndex) {
+        const remaining = this.state.buffer.slice(startIndex);
+        if (remaining.startsWith("null")) {
+          this.setValue(null);
+          return startIndex + 3;
+        }
+        return startIndex;
+      }
+      /**
+       * Parse a number value
+       */
+      parseNumber(startIndex) {
+        const remaining = this.state.buffer.slice(startIndex);
+        const match = remaining.match(/^-?\d+(\.\d+)?([eE][+-]?\d+)?/);
+        if (match) {
+          const numStr = match[0];
+          const value = numStr.includes(".") || numStr.includes("e") || numStr.includes("E") ? parseFloat(numStr) : parseInt(numStr, 10);
+          this.setValue(value);
+          return startIndex + numStr.length - 1;
+        }
+        return startIndex;
+      }
+      /**
+       * Set a value at the current path
+       */
+      setValue(value) {
+        let path;
+        if (this.state.currentKey !== null) {
+          path = [...this.state.currentPath, this.state.currentKey];
+          this.state.currentKey = null;
+        } else if (this.getCurrentContainer() === "array") {
+          path = [...this.state.currentPath];
+        } else {
+          path = [...this.state.currentPath];
+        }
+        this.setNestedValue(this.result, path, value);
+        this.pendingUpdates.push({
+          path,
+          value,
+          complete: true
+        });
+      }
+      /**
+       * Get current container type
+       */
+      getCurrentContainer() {
+        if (this.state.containerStack.length === 0) {
+          return null;
+        }
+        return this.state.containerStack[this.state.containerStack.length - 1];
+      }
+      /**
+       * Set a nested value in an object
+       */
+      setNestedValue(obj, path, value) {
+        if (path.length === 0) {
+          return;
+        }
+        let current = obj;
+        for (let i = 0; i < path.length - 1; i++) {
+          const key = path[i];
+          if (typeof current !== "object" || current === null) {
+            return;
+          }
+          const currentObj = current;
+          if (!(key in currentObj)) {
+            const nextKey = path[i + 1];
+            currentObj[key] = /^\d+$/.test(nextKey) ? [] : {};
+          }
+          current = currentObj[key];
+        }
+        const lastKey = path[path.length - 1];
+        if (typeof current === "object" && current !== null) {
+          current[lastKey] = value;
+        }
+      }
+      /**
+       * Get a nested value from an object
+       */
+      getNestedValue(obj, path) {
+        if (path.length === 0) {
+          return obj;
+        }
+        let current = obj;
+        for (const key of path) {
+          if (typeof current !== "object" || current === null) {
+            return void 0;
+          }
+          current = current[key];
+        }
+        return current;
+      }
+      /**
+       * Finalize parsing - try to complete any partial values
+       */
+      finalize() {
+        if (this.state.buffer.trim()) {
+          try {
+            const parsed = JSON.parse(this.state.buffer);
+            this.result = parsed;
+          } catch {
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/streaming/StreamingExtractor.ts
+var StreamingExtractor_exports = {};
+__export(StreamingExtractor_exports, {
+  createStreamingResult: () => createStreamingResult,
+  getPartialState: () => getPartialState
+});
+function createStreamingResult(_client, provider, options, streamingOptions) {
+  const emitter = new EventEmitter();
+  const parser = new IncrementalJsonParser();
+  let isComplete = false;
+  const current = {};
+  let finalResult;
+  let error;
+  let cancelled = false;
+  const metadata = {
+    totalChunks: 0,
+    totalChars: 0,
+    startTime: Date.now()
+  };
+  const streamPromise = executeStreamingExtraction();
+  async function executeStreamingExtraction() {
+    try {
+      const jsonSchema = zodToJsonSchema(options.response_format);
+      const messages = prepareMessages(
+        options.messages,
+        options.response_format
+      );
+      const stream = provider.createStreamingCompletion({
+        model: options.model,
+        messages,
+        mode: "json",
+        jsonSchema,
+        stream: true
+      });
+      for await (const chunk of stream) {
+        if (cancelled) {
+          break;
+        }
+        metadata.totalChunks++;
+        metadata.totalChars += chunk.content.length;
+        const updates = parser.feed(chunk.content);
+        for (const update of updates) {
+          const fieldUpdate = {
+            path: update.path.join("."),
+            value: update.value,
+            complete: update.complete,
+            timestamp: Date.now()
+          };
+          setNestedValue(current, update.path, update.value);
+          if (streamingOptions?.onFieldComplete && update.complete) {
+            streamingOptions.onFieldComplete(fieldUpdate.path, update.value);
+          }
+          emitter.emit("field", {
+            path: fieldUpdate.path,
+            value: update.value
+          });
+          if (shouldEmitPartial(current, streamingOptions)) {
+            if (streamingOptions?.onPartial) {
+              streamingOptions.onPartial(current, update.path.join("."));
+            }
+            emitter.emit("partial", {
+              data: current,
+              path: update.path.join(".")
+            });
+          }
+        }
+        if (chunk.isFinal) {
+          metadata.endTime = Date.now();
+          metadata.usage = chunk.usage;
+          break;
+        }
+      }
+      const parsedResult = parser.getResult();
+      const validation = options.response_format.safeParse(parsedResult);
+      if (validation.success) {
+        finalResult = validation.data;
+        isComplete = true;
+        emitter.emit("complete", { data: finalResult });
+      } else {
+        error = new Error(
+          `Validation failed: ${validation.error.issues.map((i) => i.message).join(", ")}`
+        );
+        emitter.emit("error", { error });
+      }
+    } catch (err) {
+      error = err instanceof Error ? err : new Error(String(err));
+      emitter.emit("error", { error });
+      if (streamingOptions?.onError) {
+        streamingOptions.onError(error);
+      }
+    }
+  }
+  function prepareMessages(messages, schema) {
+    const prompt = schemaToPrompt(schema, {
+      format: "json-schema",
+      includeConstraints: true
+    });
+    const systemIndex = messages.findIndex((m) => m.role === "system");
+    if (systemIndex >= 0) {
+      const newMessages = [...messages];
+      newMessages[systemIndex] = {
+        ...newMessages[systemIndex],
+        content: `${newMessages[systemIndex].content}
+
+Respond with valid JSON matching this schema:
+${prompt.text}`
+      };
+      return newMessages;
+    }
+    return [
+      {
+        role: "system",
+        content: `Respond with valid JSON matching this schema:
+${prompt.text}`
+      },
+      ...messages
+    ];
+  }
+  function shouldEmitPartial(partial, options2) {
+    if (!options2?.yieldPartials) {
+      return false;
+    }
+    const fieldCount = countFields(partial);
+    const minFields = options2.minFieldsBeforeYield ?? 1;
+    return fieldCount >= minFields;
+  }
+  function countFields(obj, count = 0) {
+    if (typeof obj !== "object" || obj === null) {
+      return count + 1;
+    }
+    if (Array.isArray(obj)) {
+      return obj.reduce((c, item) => countFields(item, c), count);
+    }
+    return Object.values(obj).reduce(
+      (c, value) => countFields(value, c),
+      count
+    );
+  }
+  function setNestedValue(obj, path, value) {
+    let current2 = obj;
+    for (let i = 0; i < path.length - 1; i++) {
+      const key = path[i];
+      if (!(key in current2)) {
+        const nextKey = path[i + 1];
+        current2[key] = /^\d+$/.test(nextKey) ? [] : {};
+      }
+      current2 = current2[key];
+    }
+    const lastKey = path[path.length - 1];
+    current2[lastKey] = value;
+  }
+  return {
+    async *partials() {
+      const partialQueue = [];
+      let resolveNext = null;
+      let done = false;
+      const onPartial = ({ data }) => {
+        if (resolveNext) {
+          resolveNext({ value: { ...data }, done: false });
+          resolveNext = null;
+        } else {
+          partialQueue.push({ ...data });
+        }
+      };
+      const onComplete = () => {
+        done = true;
+        if (resolveNext) {
+          resolveNext({
+            value: void 0,
+            done: true
+          });
+          resolveNext = null;
+        }
+      };
+      const onError = () => {
+        done = true;
+        if (resolveNext) {
+          resolveNext({
+            value: void 0,
+            done: true
+          });
+          resolveNext = null;
+        }
+      };
+      emitter.on("partial", onPartial);
+      emitter.on("complete", onComplete);
+      emitter.on("error", onError);
+      try {
+        while (!done || partialQueue.length > 0) {
+          if (partialQueue.length > 0) {
+            yield partialQueue.shift();
+          } else if (!done) {
+            const result = await new Promise((resolve) => {
+              resolveNext = resolve;
+            });
+            if (!result.done) {
+              yield result.value;
+            }
+          }
+        }
+      } finally {
+        emitter.off("partial", onPartial);
+        emitter.off("complete", onComplete);
+        emitter.off("error", onError);
+      }
+    },
+    async *fields() {
+      const fieldQueue = [];
+      let resolveNext = null;
+      let done = false;
+      const onField = ({ path, value }) => {
+        const update = {
+          path,
+          value,
+          complete: true,
+          timestamp: Date.now()
+        };
+        if (resolveNext) {
+          resolveNext({ value: update, done: false });
+          resolveNext = null;
+        } else {
+          fieldQueue.push(update);
+        }
+      };
+      const onComplete = () => {
+        done = true;
+        if (resolveNext) {
+          resolveNext({
+            value: void 0,
+            done: true
+          });
+          resolveNext = null;
+        }
+      };
+      const onError = () => {
+        done = true;
+        if (resolveNext) {
+          resolveNext({
+            value: void 0,
+            done: true
+          });
+          resolveNext = null;
+        }
+      };
+      emitter.on("field", onField);
+      emitter.on("complete", onComplete);
+      emitter.on("error", onError);
+      try {
+        while (!done || fieldQueue.length > 0) {
+          if (fieldQueue.length > 0) {
+            yield fieldQueue.shift();
+          } else if (!done) {
+            const result = await new Promise(
+              (resolve) => {
+                resolveNext = resolve;
+              }
+            );
+            if (!result.done) {
+              yield result.value;
+            }
+          }
+        }
+      } finally {
+        emitter.off("field", onField);
+        emitter.off("complete", onComplete);
+        emitter.off("error", onError);
+      }
+    },
+    async final() {
+      await streamPromise;
+      if (error) {
+        throw error;
+      }
+      if (!finalResult) {
+        throw new Error("Stream completed without valid result");
+      }
+      return finalResult;
+    },
+    onPartial(callback) {
+      emitter.on("partial", ({ data, path }) => callback(data, path));
+    },
+    onField(callback) {
+      emitter.on("field", ({ path, value }) => callback(path, value));
+    },
+    onComplete(callback) {
+      emitter.on("complete", ({ data }) => callback(data));
+    },
+    onError(callback) {
+      emitter.on("error", ({ error: error2 }) => callback(error2));
+    },
+    cancel() {
+      cancelled = true;
+    },
+    get isComplete() {
+      return isComplete;
+    },
+    get current() {
+      return { ...current };
+    }
+  };
+}
+function getPartialState(schema, partial) {
+  const fieldPaths = getAllFieldPaths(partial);
+  const schemaFieldPaths = getSchemaFieldPaths(schema);
+  const completedFields = fieldPaths.filter((p) => {
+    const value = getNestedValue2(partial, p);
+    return value !== void 0;
+  });
+  const inProgressFields = schemaFieldPaths.filter(
+    (p) => !completedFields.includes(p)
+  );
+  const validation = validatePartial(schema, partial);
+  return {
+    data: partial,
+    completedFields,
+    inProgressFields,
+    completionPercent: completedFields.length / schemaFieldPaths.length * 100,
+    isValid: validation.success
+  };
+}
+function getAllFieldPaths(obj, prefix = "", paths = []) {
+  if (typeof obj !== "object" || obj === null) {
+    if (prefix) {
+      paths.push(prefix);
+    }
+    return paths;
+  }
+  if (Array.isArray(obj)) {
+    obj.forEach((item, index) => {
+      getAllFieldPaths(item, `${prefix}[${index}]`, paths);
+    });
+    return paths;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const newPrefix = prefix ? `${prefix}.${key}` : key;
+    getAllFieldPaths(value, newPrefix, paths);
+  }
+  return paths;
+}
+function getSchemaFieldPaths(schema, prefix = "") {
+  const paths = [];
+  if (schema instanceof z.ZodObject) {
+    const shape = schema.shape;
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      const newPrefix = prefix ? `${prefix}.${key}` : key;
+      paths.push(...getSchemaFieldPaths(fieldSchema, newPrefix));
+    }
+  } else if (schema instanceof z.ZodArray) {
+    if (prefix) {
+      paths.push(prefix);
+    }
+  } else {
+    if (prefix) {
+      paths.push(prefix);
+    }
+  }
+  return paths.length > 0 ? paths : [prefix].filter(Boolean);
+}
+function getNestedValue2(obj, path) {
+  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (typeof current !== "object" || current === null) {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+var init_StreamingExtractor = __esm({
+  "src/streaming/StreamingExtractor.ts"() {
+    init_SchemaToPrompt();
+    init_SchemaValidator();
+    init_IncrementalJsonParser();
+  }
+});
+
+// src/core/StructuredClient.ts
+init_SchemaToPrompt();
+init_SchemaValidator();
+var DEFAULT_RETRY_CONFIG = {
+  maxAttempts: 3,
+  backoffMultiplier: 1.5,
+  initialDelay: 1e3,
+  maxDelay: 1e4,
+  retryOn: ["validation_error", "parse_error"]
+};
+var StructuredClient = class extends EventEmitter {
+  provider;
+  config;
+  constructor(provider, config = {}) {
+    super();
+    this.provider = provider;
+    this.config = {
+      defaultMode: config.defaultMode ?? "json",
+      defaultRetry: { ...DEFAULT_RETRY_CONFIG, ...config.defaultRetry },
+      enableFixHints: config.enableFixHints ?? true,
+      validatePartials: config.validatePartials ?? false,
+      ...config
+    };
+  }
+  /**
+   * Extract structured data from an LLM response
+   */
+  async extract(options) {
+    const requestId = this.generateRequestId();
+    const startTime = Date.now();
+    const attempts = [];
+    const mode = this.resolveMode(options.mode);
+    const retryConfig = {
+      ...DEFAULT_RETRY_CONFIG,
+      ...this.config.defaultRetry,
+      ...options.retry
+    };
+    this.emit("extraction:start", { requestId, mode });
+    let lastError;
+    let currentMode = mode;
+    const totalTokens = {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0
+    };
+    for (let attempt = 1; attempt <= retryConfig.maxAttempts; attempt++) {
+      this.emit("extraction:attempt", {
+        requestId,
+        attempt,
+        mode: currentMode
+      });
+      try {
+        const result = await this.executeExtraction(
+          options,
+          currentMode,
+          attempts,
+          attempt
+        );
+        if (result.usage) {
+          totalTokens.promptTokens += result.usage.promptTokens;
+          totalTokens.completionTokens += result.usage.completionTokens;
+          totalTokens.totalTokens += result.usage.totalTokens;
+        }
+        const validation = validateSchema(
+          options.response_format,
+          result.content
+        );
+        if (validation.success) {
+          const attemptRecord = {
+            attempt,
+            mode: currentMode,
+            success: true,
+            duration: Date.now() - startTime,
+            rawResponse: result.rawResponse
+          };
+          attempts.push(attemptRecord);
+          this.emit("extraction:success", {
+            requestId,
+            data: validation.data,
+            attempts: attempt
+          });
+          return {
+            success: true,
+            data: validation.data,
+            raw: result.rawResponse,
+            metadata: this.createMetadata(
+              startTime,
+              attempts,
+              totalTokens,
+              options.model
+            )
+          };
+        }
+        const validationErrors = validation.errors ?? [];
+        this.emit("validation:failed", { requestId, errors: validationErrors });
+        const hints = this.config.enableFixHints ? getValidationHints(options.response_format, result.content) : [];
+        attempts.push({
+          attempt,
+          mode: currentMode,
+          success: false,
+          duration: Date.now() - startTime,
+          rawResponse: result.rawResponse,
+          error: "Validation failed",
+          validationErrors
+        });
+        lastError = this.createStructuredError(
+          "Validation failed",
+          "VALIDATION_ERROR",
+          attempts,
+          validationErrors,
+          result.content
+        );
+        if (attempt < retryConfig.maxAttempts && this.shouldRetry("validation_error", retryConfig, attempt)) {
+          this.emit("extraction:retry", {
+            requestId,
+            attempt,
+            reason: "validation_error",
+            hints
+          });
+          if (hints.length > 0 && this.config.enableFixHints) {
+            options = this.addFixHintsToMessages(
+              options,
+              hints,
+              validationErrors
+            );
+          }
+          await this.delay(this.calculateBackoff(attempt, retryConfig));
+          if (this.shouldSwitchMode(currentMode, attempt, options.mode)) {
+            const newMode = this.getNextMode(currentMode);
+            this.emit("mode:switch", {
+              requestId,
+              from: currentMode,
+              to: newMode
+            });
+            currentMode = newMode;
+          }
+          continue;
+        }
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.emit("extraction:error", { requestId, error: err, attempt });
+        const errorType = this.classifyError(err);
+        attempts.push({
+          attempt,
+          mode: currentMode,
+          success: false,
+          duration: Date.now() - startTime,
+          error: err.message
+        });
+        lastError = err;
+        if (attempt < retryConfig.maxAttempts && this.shouldRetry(errorType, retryConfig, attempt)) {
+          this.emit("extraction:retry", {
+            requestId,
+            attempt,
+            reason: errorType,
+            hints: []
+          });
+          await this.delay(this.calculateBackoff(attempt, retryConfig));
+          continue;
+        }
+      }
+    }
+    return {
+      success: false,
+      error: lastError ?? new Error("All extraction attempts failed"),
+      raw: attempts[attempts.length - 1]?.rawResponse,
+      metadata: this.createMetadata(
+        startTime,
+        attempts,
+        totalTokens,
+        options.model
+      )
+    };
+  }
+  /**
+   * Extract with streaming partial results
+   */
+  async extractStream(options, streamingOptions) {
+    const { createStreamingResult: createStreamingResult2 } = await Promise.resolve().then(() => (init_StreamingExtractor(), StreamingExtractor_exports));
+    return createStreamingResult2(
+      this,
+      this.provider,
+      options,
+      streamingOptions
+    );
+  }
+  /**
+   * Execute a single extraction attempt
+   */
+  async executeExtraction(options, mode, _previousAttempts, _attempt) {
+    const { model, messages } = options;
+    const jsonSchema = zodToJsonSchema(options.response_format);
+    let response;
+    switch (mode) {
+      case "json":
+        response = await this.extractWithJsonMode(model, messages, jsonSchema);
+        break;
+      case "tool":
+        response = await this.extractWithToolMode(
+          model,
+          messages,
+          jsonSchema,
+          options.response_format
+        );
+        break;
+      case "prompt":
+        response = await this.extractWithPromptMode(
+          model,
+          messages,
+          options.response_format
+        );
+        break;
+      case "hybrid":
+        response = await this.extractWithJsonMode(model, messages, jsonSchema);
+        break;
+      default:
+        throw new Error(`Unknown extraction mode: ${mode}`);
+    }
+    const content = this.parseResponse(response, mode);
+    return {
+      content,
+      rawResponse: response.content,
+      usage: response.usage
+    };
+  }
+  /**
+   * Extract using JSON mode
+   */
+  async extractWithJsonMode(model, messages, jsonSchema) {
+    return this.provider.createCompletion({
+      model,
+      messages,
+      mode: "json",
+      jsonSchema
+    });
+  }
+  /**
+   * Extract using tool/function calling mode
+   */
+  async extractWithToolMode(model, messages, jsonSchema, _schema) {
+    const toolDefinition = {
+      type: "function",
+      function: {
+        name: "extract_data",
+        description: "Extract structured data from the response",
+        parameters: jsonSchema,
+        strict: true
+      }
+    };
+    return this.provider.createCompletion({
+      model,
+      messages,
+      mode: "tool",
+      toolDefinition
+    });
+  }
+  /**
+   * Extract using prompt engineering mode
+   */
+  async extractWithPromptMode(model, messages, schema) {
+    const prompt = schemaToPrompt(schema, {
+      format: "natural",
+      includeConstraints: true,
+      includeExamples: true
+    });
+    const enhancedMessages = this.addSchemaPromptToMessages(
+      messages,
+      prompt.text
+    );
+    return this.provider.createCompletion({
+      model,
+      messages: enhancedMessages,
+      mode: "prompt"
+    });
+  }
+  /**
+   * Parse the response based on mode
+   */
+  parseResponse(response, mode) {
+    if (mode === "tool" && response.toolCalls && response.toolCalls.length > 0) {
+      try {
+        return JSON.parse(response.toolCalls[0].arguments);
+      } catch {
+        throw new Error("Failed to parse tool call arguments");
+      }
+    }
+    return this.extractJsonFromContent(response.content);
+  }
+  /**
+   * Extract JSON from text content
+   */
+  extractJsonFromContent(content) {
+    try {
+      return JSON.parse(content);
+    } catch {
+    }
+    const codeBlockMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (codeBlockMatch) {
+      try {
+        return JSON.parse(codeBlockMatch[1].trim());
+      } catch {
+      }
+    }
+    const jsonMatch = content.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
+    if (jsonMatch) {
+      try {
+        return JSON.parse(jsonMatch[1]);
+      } catch {
+      }
+    }
+    throw new Error("No valid JSON found in response");
+  }
+  /**
+   * Add schema prompt to messages
+   */
+  addSchemaPromptToMessages(messages, schemaPrompt) {
+    const systemIndex = messages.findIndex((m) => m.role === "system");
+    if (systemIndex >= 0) {
+      const newMessages = [...messages];
+      newMessages[systemIndex] = {
+        ...newMessages[systemIndex],
+        content: `${newMessages[systemIndex].content}
+
+${schemaPrompt}
+
+Respond with valid JSON only.`
+      };
+      return newMessages;
+    }
+    return [
+      {
+        role: "system",
+        content: `${schemaPrompt}
+
+Respond with valid JSON only.`
+      },
+      ...messages
+    ];
+  }
+  /**
+   * Add fix hints to messages for retry
+   */
+  addFixHintsToMessages(options, hints, errors) {
+    const hintsText = hints.join("\n");
+    const errorsText = errors.map((e) => `- ${e.path.join(".")}: ${e.message}`).join("\n");
+    const fixPrompt = `Your previous response had validation errors:
+${errorsText}
+
+Please fix these issues:
+${hintsText}`;
+    const newMessages = [
+      ...options.messages,
+      {
+        role: "user",
+        content: fixPrompt
+      }
+    ];
+    return {
+      ...options,
+      messages: newMessages
+    };
+  }
+  /**
+   * Resolve the extraction mode
+   */
+  resolveMode(modeConfig) {
+    if (!modeConfig) {
+      return this.config.defaultMode ?? "json";
+    }
+    if (typeof modeConfig === "string") {
+      return modeConfig;
+    }
+    return modeConfig.mode;
+  }
+  /**
+   * Check if we should retry
+   */
+  shouldRetry(errorType, config, _attempt) {
+    return (config.retryOn ?? []).includes(
+      errorType
+    );
+  }
+  /**
+   * Classify an error for retry logic
+   */
+  classifyError(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("rate limit") || message.includes("429")) {
+      return "rate_limit";
+    }
+    if (message.includes("timeout")) {
+      return "timeout";
+    }
+    if (message.includes("json") || message.includes("parse")) {
+      return "parse_error";
+    }
+    if (message.includes("validation")) {
+      return "validation_error";
+    }
+    return "unknown_error";
+  }
+  /**
+   * Check if mode should be switched (for hybrid mode)
+   */
+  shouldSwitchMode(_currentMode, attempt, modeConfig) {
+    if (!modeConfig || typeof modeConfig === "string") {
+      return false;
+    }
+    if (!("mode" in modeConfig) || modeConfig.mode !== "hybrid") {
+      return false;
+    }
+    const hybridConfig = modeConfig;
+    return attempt > 0 && !!hybridConfig.fallbackOrder && hybridConfig.fallbackOrder.length > 0;
+  }
+  /**
+   * Get next mode in fallback order
+   */
+  getNextMode(currentMode) {
+    const fallbackOrder = ["json", "tool", "prompt"];
+    const currentIndex = fallbackOrder.indexOf(currentMode);
+    if (currentIndex < fallbackOrder.length - 1) {
+      return fallbackOrder[currentIndex + 1];
+    }
+    return fallbackOrder[0];
+  }
+  /**
+   * Calculate backoff delay
+   */
+  calculateBackoff(attempt, config) {
+    const delay = (config.initialDelay ?? 1e3) * Math.pow(config.backoffMultiplier ?? 1.5, attempt - 1);
+    return Math.min(delay, config.maxDelay ?? 1e4);
+  }
+  /**
+   * Delay helper
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Generate a request ID
+   */
+  generateRequestId() {
+    return `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Create extraction metadata
+   */
+  createMetadata(startTime, attempts, usage, model) {
+    return {
+      totalAttempts: attempts.length,
+      totalDuration: Date.now() - startTime,
+      finalMode: attempts[attempts.length - 1]?.mode ?? "json",
+      tokenUsage: usage,
+      attempts,
+      model
+    };
+  }
+  /**
+   * Create a structured error
+   */
+  createStructuredError(message, code, attempts, validationErrors, partial) {
+    const error = new Error(message);
+    error.name = "StructuredError";
+    error.code = code;
+    error.attempts = attempts;
+    error.validationErrors = validationErrors;
+    error.partial = partial;
+    return error;
+  }
+  /**
+   * Get provider capabilities
+   */
+  getProviderCapabilities(model) {
+    return this.provider.getCapabilities(model);
+  }
+  /**
+   * Check if a mode is supported
+   */
+  supportsMode(mode, model) {
+    const capabilities = this.provider.getCapabilities(model);
+    switch (mode) {
+      case "json":
+        return capabilities.jsonMode;
+      case "tool":
+        return capabilities.toolCalling;
+      case "prompt":
+        return true;
+      // Always supported
+      case "hybrid":
+        return capabilities.jsonMode || capabilities.toolCalling;
+      default:
+        return false;
+    }
+  }
+};
+function createStructuredClient(provider, config) {
+  return new StructuredClient(provider, config);
+}
+
+// src/schema/index.ts
+init_SchemaToPrompt();
+init_SchemaValidator();
+
+// src/streaming/index.ts
+init_StreamingExtractor();
+init_IncrementalJsonParser();
+
+// src/providers/OpenAIAdapter.ts
+var MODEL_CAPABILITIES = {
+  "gpt-4o": {
+    jsonMode: true,
+    strictJsonMode: true,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 128e3,
+    maxOutputTokens: 16384
+  },
+  "gpt-4o-mini": {
+    jsonMode: true,
+    strictJsonMode: true,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 128e3,
+    maxOutputTokens: 16384
+  },
+  "gpt-4-turbo": {
+    jsonMode: true,
+    strictJsonMode: false,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 128e3,
+    maxOutputTokens: 4096
+  },
+  "gpt-4": {
+    jsonMode: true,
+    strictJsonMode: false,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 8192,
+    maxOutputTokens: 4096
+  },
+  "gpt-3.5-turbo": {
+    jsonMode: true,
+    strictJsonMode: false,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 16385,
+    maxOutputTokens: 4096
+  },
+  "o1-preview": {
+    jsonMode: false,
+    strictJsonMode: false,
+    toolCalling: false,
+    streaming: false,
+    systemMessages: false,
+    maxContextWindow: 128e3,
+    maxOutputTokens: 32768
+  },
+  "o1-mini": {
+    jsonMode: false,
+    strictJsonMode: false,
+    toolCalling: false,
+    streaming: false,
+    systemMessages: false,
+    maxContextWindow: 128e3,
+    maxOutputTokens: 65536
+  }
+};
+var OpenAIAdapter = class {
+  name = "openai";
+  client;
+  constructor(client, _options = {}) {
+    this.client = client;
+  }
+  /**
+   * Get capabilities for a model
+   */
+  getCapabilities(model) {
+    const base = MODEL_CAPABILITIES[model] ?? MODEL_CAPABILITIES["gpt-4o"];
+    return {
+      jsonMode: base.jsonMode ?? true,
+      strictJsonMode: base.strictJsonMode ?? false,
+      toolCalling: base.toolCalling ?? true,
+      streaming: base.streaming ?? true,
+      systemMessages: base.systemMessages ?? true,
+      maxContextWindow: base.maxContextWindow,
+      maxOutputTokens: base.maxOutputTokens
+    };
+  }
+  /**
+   * Check if JSON mode is available
+   */
+  supportsJsonMode(model) {
+    return this.getCapabilities(model).jsonMode;
+  }
+  /**
+   * Check if tool calling is available
+   */
+  supportsToolCalling(model) {
+    return this.getCapabilities(model).toolCalling;
+  }
+  /**
+   * Create a completion request
+   */
+  async createCompletion(request) {
+    const params = this.buildRequestParams(request);
+    const response = await this.client.chat.completions.create(params);
+    return this.parseResponse(response);
+  }
+  /**
+   * Create a streaming completion request
+   */
+  async *createStreamingCompletion(request) {
+    const params = this.buildRequestParams(request);
+    params.stream = true;
+    params.stream_options = { include_usage: true };
+    const stream = await this.client.chat.completions.create(params);
+    const asyncStream = stream;
+    const toolCalls = /* @__PURE__ */ new Map();
+    for await (const chunk of asyncStream) {
+      const choice = chunk.choices[0];
+      if (!choice) continue;
+      const delta = choice.delta;
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const existing = toolCalls.get(tc.index) ?? { arguments: "" };
+          if (tc.id) existing.id = tc.id;
+          if (tc.function?.name) existing.name = tc.function.name;
+          if (tc.function?.arguments)
+            existing.arguments += tc.function.arguments;
+          toolCalls.set(tc.index, existing);
+        }
+      }
+      const isFinal = choice.finish_reason !== null;
+      yield {
+        content: delta.content ?? "",
+        isFinal,
+        finishReason: choice.finish_reason ?? void 0,
+        usage: chunk.usage ? {
+          promptTokens: chunk.usage.prompt_tokens,
+          completionTokens: chunk.usage.completion_tokens,
+          totalTokens: chunk.usage.total_tokens
+        } : void 0,
+        toolCallDeltas: delta.tool_calls?.map((tc) => ({
+          index: tc.index,
+          id: tc.id,
+          name: tc.function?.name,
+          arguments: tc.function?.arguments
+        }))
+      };
+    }
+  }
+  /**
+   * Format messages for OpenAI
+   */
+  formatMessages(messages) {
+    return messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content,
+      name: msg.name
+    }));
+  }
+  /**
+   * Format JSON schema for OpenAI
+   */
+  formatJsonSchema(schema) {
+    return {
+      type: "json_schema",
+      json_schema: {
+        name: "response",
+        schema,
+        strict: true
+      }
+    };
+  }
+  /**
+   * Format tool definition for OpenAI
+   */
+  formatToolDefinition(tool) {
+    return {
+      type: "function",
+      function: {
+        name: tool.function.name,
+        description: tool.function.description,
+        parameters: tool.function.parameters,
+        strict: tool.function.strict
+      }
+    };
+  }
+  /**
+   * Build request parameters
+   */
+  buildRequestParams(request) {
+    const params = {
+      model: request.model,
+      messages: this.formatMessages(request.messages),
+      temperature: request.temperature,
+      max_tokens: request.maxTokens
+    };
+    switch (request.mode) {
+      case "json":
+        if (request.jsonSchema) {
+          const caps = this.getCapabilities(request.model);
+          if (caps.strictJsonMode) {
+            params.response_format = {
+              type: "json_schema",
+              json_schema: {
+                name: "response",
+                schema: request.jsonSchema,
+                strict: true
+              }
+            };
+          } else {
+            params.response_format = { type: "json_object" };
+          }
+        }
+        break;
+      case "tool":
+        if (request.toolDefinition) {
+          params.tools = [this.formatToolDefinition(request.toolDefinition)];
+          params.tool_choice = {
+            type: "function",
+            function: { name: request.toolDefinition.function.name }
+          };
+        }
+        break;
+    }
+    if (request.options) {
+      Object.assign(params, request.options);
+    }
+    return params;
+  }
+  /**
+   * Parse response
+   */
+  parseResponse(response) {
+    const choice = response.choices[0];
+    const message = choice?.message;
+    let toolCalls;
+    if (message?.tool_calls && message.tool_calls.length > 0) {
+      toolCalls = message.tool_calls.map((tc) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: tc.function.arguments
+      }));
+    }
+    return {
+      content: message?.content ?? "",
+      usage: response.usage ? {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens
+      } : void 0,
+      finishReason: choice?.finish_reason,
+      toolCalls,
+      raw: response
+    };
+  }
+};
+function createOpenAIAdapter(client, options) {
+  return new OpenAIAdapter(client, options);
+}
+
+// src/providers/AnthropicAdapter.ts
+var MODEL_CAPABILITIES2 = {
+  "claude-opus-4-20250514": {
+    jsonMode: false,
+    strictJsonMode: false,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 2e5,
+    maxOutputTokens: 32768
+  },
+  "claude-sonnet-4-20250514": {
+    jsonMode: false,
+    strictJsonMode: false,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 2e5,
+    maxOutputTokens: 64e3
+  },
+  "claude-3-5-sonnet-20241022": {
+    jsonMode: false,
+    strictJsonMode: false,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 2e5,
+    maxOutputTokens: 8192
+  },
+  "claude-3-5-haiku-20241022": {
+    jsonMode: false,
+    strictJsonMode: false,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 2e5,
+    maxOutputTokens: 8192
+  },
+  "claude-3-opus-20240229": {
+    jsonMode: false,
+    strictJsonMode: false,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 2e5,
+    maxOutputTokens: 4096
+  },
+  "claude-3-sonnet-20240229": {
+    jsonMode: false,
+    strictJsonMode: false,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 2e5,
+    maxOutputTokens: 4096
+  },
+  "claude-3-haiku-20240307": {
+    jsonMode: false,
+    strictJsonMode: false,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 2e5,
+    maxOutputTokens: 4096
+  }
+};
+var AnthropicAdapter = class {
+  name = "anthropic";
+  client;
+  options;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.options = options;
+  }
+  /**
+   * Get capabilities for a model
+   */
+  getCapabilities(model) {
+    const modelKey = Object.keys(MODEL_CAPABILITIES2).find(
+      (key) => model.includes(key) || key.includes(model)
+    );
+    const base = modelKey ? MODEL_CAPABILITIES2[modelKey] : MODEL_CAPABILITIES2["claude-3-5-sonnet-20241022"];
+    return {
+      jsonMode: base.jsonMode ?? false,
+      strictJsonMode: base.strictJsonMode ?? false,
+      toolCalling: base.toolCalling ?? true,
+      streaming: base.streaming ?? true,
+      systemMessages: base.systemMessages ?? true,
+      maxContextWindow: base.maxContextWindow,
+      maxOutputTokens: base.maxOutputTokens
+    };
+  }
+  /**
+   * Check if JSON mode is available
+   */
+  supportsJsonMode(_model) {
+    return false;
+  }
+  /**
+   * Check if tool calling is available
+   */
+  supportsToolCalling(model) {
+    return this.getCapabilities(model).toolCalling;
+  }
+  /**
+   * Create a completion request
+   */
+  async createCompletion(request) {
+    const params = this.buildRequestParams(request);
+    const response = await this.client.messages.create(params);
+    return this.parseResponse(response);
+  }
+  /**
+   * Create a streaming completion request
+   */
+  async *createStreamingCompletion(request) {
+    const params = this.buildRequestParams(request);
+    params.stream = true;
+    const stream = await this.client.messages.create(params);
+    const asyncStream = stream;
+    let toolCallBuffer = null;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    for await (const event of asyncStream) {
+      switch (event.type) {
+        case "message_start":
+          if (event.message?.usage) {
+            inputTokens = event.message.usage.input_tokens;
+          }
+          break;
+        case "content_block_start":
+          if (event.content_block?.type === "tool_use") {
+            toolCallBuffer = {
+              id: event.content_block.id,
+              name: event.content_block.name,
+              arguments: ""
+            };
+          }
+          break;
+        case "content_block_delta":
+          if (event.delta?.type === "text_delta" && event.delta.text) {
+            yield {
+              content: event.delta.text,
+              isFinal: false
+            };
+          } else if (event.delta?.type === "input_json_delta" && event.delta.partial_json) {
+            if (toolCallBuffer) {
+              toolCallBuffer.arguments += event.delta.partial_json;
+            }
+            yield {
+              content: "",
+              isFinal: false,
+              toolCallDeltas: toolCallBuffer ? [
+                {
+                  index: 0,
+                  id: toolCallBuffer.id,
+                  name: toolCallBuffer.name,
+                  arguments: event.delta.partial_json
+                }
+              ] : void 0
+            };
+          }
+          break;
+        case "message_delta":
+          if (event.usage) {
+            outputTokens = event.usage.output_tokens;
+          }
+          break;
+        case "message_stop":
+          yield {
+            content: "",
+            isFinal: true,
+            usage: {
+              promptTokens: inputTokens,
+              completionTokens: outputTokens,
+              totalTokens: inputTokens + outputTokens
+            }
+          };
+          break;
+      }
+    }
+  }
+  /**
+   * Format messages for Anthropic
+   */
+  formatMessages(messages) {
+    const systemMessage = messages.find((m) => m.role === "system");
+    const otherMessages = messages.filter((m) => m.role !== "system");
+    return {
+      system: systemMessage?.content,
+      messages: otherMessages.map((msg) => ({
+        role: msg.role === "assistant" ? "assistant" : "user",
+        content: msg.content
+      }))
+    };
+  }
+  /**
+   * Format JSON schema for Anthropic (via tool calling)
+   */
+  formatJsonSchema(schema) {
+    return {
+      name: "extract_structured_data",
+      description: "Extract structured data from the conversation",
+      input_schema: schema
+    };
+  }
+  /**
+   * Format tool definition for Anthropic
+   */
+  formatToolDefinition(tool) {
+    return {
+      name: tool.function.name,
+      description: tool.function.description,
+      input_schema: tool.function.parameters
+    };
+  }
+  /**
+   * Build request parameters
+   */
+  buildRequestParams(request) {
+    const formatted = this.formatMessages(request.messages);
+    const params = {
+      model: request.model,
+      messages: formatted.messages,
+      max_tokens: request.maxTokens ?? 4096
+    };
+    if (formatted.system) {
+      params.system = formatted.system;
+    }
+    if (request.temperature !== void 0) {
+      params.temperature = request.temperature;
+    }
+    switch (request.mode) {
+      case "json":
+        if (request.jsonSchema) {
+          params.tools = [this.formatJsonSchema(request.jsonSchema)];
+          params.tool_choice = {
+            type: "tool",
+            name: "extract_structured_data"
+          };
+        }
+        break;
+      case "tool":
+        if (request.toolDefinition) {
+          params.tools = [this.formatToolDefinition(request.toolDefinition)];
+          params.tool_choice = {
+            type: "tool",
+            name: request.toolDefinition.function.name
+          };
+        }
+        break;
+      case "prompt":
+        if (params.system) {
+          params.system = `${params.system}
+
+Respond with valid JSON only.`;
+        } else {
+          params.system = "Respond with valid JSON only.";
+        }
+        break;
+    }
+    if (this.options.metadata) {
+      params.metadata = this.options.metadata;
+    }
+    if (request.options) {
+      Object.assign(params, request.options);
+    }
+    return params;
+  }
+  /**
+   * Parse response
+   */
+  parseResponse(response) {
+    let content = "";
+    let toolCalls;
+    for (const block of response.content) {
+      if (block.type === "text" && block.text) {
+        content += block.text;
+      } else if (block.type === "tool_use") {
+        if (!toolCalls) {
+          toolCalls = [];
+        }
+        toolCalls.push({
+          id: block.id ?? "",
+          name: block.name ?? "",
+          arguments: JSON.stringify(block.input)
+        });
+      }
+    }
+    return {
+      content,
+      usage: {
+        promptTokens: response.usage.input_tokens,
+        completionTokens: response.usage.output_tokens,
+        totalTokens: response.usage.input_tokens + response.usage.output_tokens
+      },
+      finishReason: response.stop_reason ?? void 0,
+      toolCalls,
+      raw: response
+    };
+  }
+};
+function createAnthropicAdapter(client, options) {
+  return new AnthropicAdapter(client, options);
+}
+
+// src/providers/GoogleAdapter.ts
+var MODEL_CAPABILITIES3 = {
+  "gemini-2.0-flash": {
+    jsonMode: true,
+    strictJsonMode: true,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 1e6,
+    maxOutputTokens: 8192
+  },
+  "gemini-2.0-flash-lite": {
+    jsonMode: true,
+    strictJsonMode: true,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 1e6,
+    maxOutputTokens: 8192
+  },
+  "gemini-1.5-pro": {
+    jsonMode: true,
+    strictJsonMode: true,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 2e6,
+    maxOutputTokens: 8192
+  },
+  "gemini-1.5-flash": {
+    jsonMode: true,
+    strictJsonMode: true,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 1e6,
+    maxOutputTokens: 8192
+  },
+  "gemini-1.0-pro": {
+    jsonMode: true,
+    strictJsonMode: false,
+    toolCalling: true,
+    streaming: true,
+    systemMessages: true,
+    maxContextWindow: 32e3,
+    maxOutputTokens: 8192
+  }
+};
+var GoogleAdapter = class {
+  name = "google";
+  client;
+  options;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.options = options;
+  }
+  /**
+   * Get capabilities for a model
+   */
+  getCapabilities(model) {
+    const modelKey = Object.keys(MODEL_CAPABILITIES3).find(
+      (key) => model.includes(key) || key.includes(model)
+    );
+    const base = modelKey ? MODEL_CAPABILITIES3[modelKey] : MODEL_CAPABILITIES3["gemini-2.0-flash"];
+    return {
+      jsonMode: base.jsonMode ?? true,
+      strictJsonMode: base.strictJsonMode ?? true,
+      toolCalling: base.toolCalling ?? true,
+      streaming: base.streaming ?? true,
+      systemMessages: base.systemMessages ?? true,
+      maxContextWindow: base.maxContextWindow,
+      maxOutputTokens: base.maxOutputTokens
+    };
+  }
+  /**
+   * Check if JSON mode is available
+   */
+  supportsJsonMode(model) {
+    return this.getCapabilities(model).jsonMode;
+  }
+  /**
+   * Check if tool calling is available
+   */
+  supportsToolCalling(model) {
+    return this.getCapabilities(model).toolCalling;
+  }
+  /**
+   * Create a completion request
+   */
+  async createCompletion(request) {
+    const model = this.getModel(request);
+    const contents = this.formatContents(request.messages);
+    const result = await model.generateContent({ contents });
+    return this.parseResponse(result.response);
+  }
+  /**
+   * Create a streaming completion request
+   */
+  async *createStreamingCompletion(request) {
+    const model = this.getModel(request);
+    const contents = this.formatContents(request.messages);
+    const streamResult = await model.generateContentStream({ contents });
+    for await (const chunk of streamResult.stream) {
+      const text = chunk.text();
+      const candidate = chunk.candidates?.[0];
+      const isFinal = candidate?.finishReason !== void 0;
+      yield {
+        content: text,
+        isFinal,
+        finishReason: candidate?.finishReason,
+        usage: chunk.usageMetadata ? {
+          promptTokens: chunk.usageMetadata.promptTokenCount,
+          completionTokens: chunk.usageMetadata.candidatesTokenCount,
+          totalTokens: chunk.usageMetadata.totalTokenCount
+        } : void 0
+      };
+    }
+  }
+  /**
+   * Format messages for Google
+   */
+  formatMessages(messages) {
+    return this.formatContents(messages);
+  }
+  /**
+   * Format JSON schema for Google
+   */
+  formatJsonSchema(schema) {
+    return {
+      responseMimeType: "application/json",
+      responseSchema: this.convertToGoogleSchema(schema)
+    };
+  }
+  /**
+   * Format tool definition for Google
+   */
+  formatToolDefinition(tool) {
+    return {
+      functionDeclarations: [
+        {
+          name: tool.function.name,
+          description: tool.function.description,
+          parameters: this.convertToGoogleSchema(tool.function.parameters)
+        }
+      ]
+    };
+  }
+  /**
+   * Get the generative model with configuration
+   */
+  getModel(request) {
+    const generationConfig = {};
+    if (request.temperature !== void 0) {
+      generationConfig.temperature = request.temperature;
+    }
+    if (request.maxTokens !== void 0) {
+      generationConfig.maxOutputTokens = request.maxTokens;
+    }
+    let tools;
+    let toolConfig;
+    switch (request.mode) {
+      case "json":
+        if (request.jsonSchema) {
+          generationConfig.responseMimeType = "application/json";
+          generationConfig.responseSchema = this.convertToGoogleSchema(
+            request.jsonSchema
+          );
+        }
+        break;
+      case "tool":
+        if (request.toolDefinition) {
+          tools = [
+            {
+              functionDeclarations: [
+                {
+                  name: request.toolDefinition.function.name,
+                  description: request.toolDefinition.function.description,
+                  parameters: this.convertToGoogleSchema(
+                    request.toolDefinition.function.parameters
+                  )
+                }
+              ]
+            }
+          ];
+          toolConfig = {
+            functionCallingConfig: {
+              mode: "ANY",
+              allowedFunctionNames: [request.toolDefinition.function.name]
+            }
+          };
+        }
+        break;
+    }
+    if (this.options.generationConfig) {
+      Object.assign(generationConfig, this.options.generationConfig);
+    }
+    return this.client.getGenerativeModel({
+      model: request.model,
+      generationConfig,
+      tools,
+      toolConfig
+    });
+  }
+  /**
+   * Format contents for Google API
+   */
+  formatContents(messages) {
+    const contents = [];
+    const systemMessage = messages.find((m) => m.role === "system");
+    const otherMessages = messages.filter((m) => m.role !== "system");
+    if (systemMessage) {
+      if (otherMessages.length > 0 && otherMessages[0].role === "user") {
+        otherMessages[0] = {
+          ...otherMessages[0],
+          content: `${systemMessage.content}
+
+${otherMessages[0].content}`
+        };
+      } else {
+        contents.push({
+          role: "user",
+          parts: [{ text: systemMessage.content }]
+        });
+      }
+    }
+    for (const msg of otherMessages) {
+      contents.push({
+        role: msg.role === "assistant" ? "model" : "user",
+        parts: [{ text: msg.content }]
+      });
+    }
+    return contents;
+  }
+  /**
+   * Convert JSON Schema to Google's schema format
+   */
+  convertToGoogleSchema(schema) {
+    const converted = {};
+    if (schema.type) {
+      converted.type = Array.isArray(schema.type) ? schema.type[0].toUpperCase() : schema.type.toUpperCase();
+    }
+    if (schema.description) {
+      converted.description = schema.description;
+    }
+    if (schema.enum) {
+      converted.enum = schema.enum;
+    }
+    if (schema.properties) {
+      converted.properties = Object.fromEntries(
+        Object.entries(schema.properties).map(([key, prop]) => [
+          key,
+          this.convertToGoogleSchema(prop)
+        ])
+      );
+    }
+    if (schema.required) {
+      converted.required = schema.required;
+    }
+    if (schema.items) {
+      converted.items = this.convertToGoogleSchema(schema.items);
+    }
+    if (schema.minimum !== void 0) {
+      converted.minimum = schema.minimum;
+    }
+    if (schema.maximum !== void 0) {
+      converted.maximum = schema.maximum;
+    }
+    if (schema.minLength !== void 0) {
+      converted.minLength = schema.minLength;
+    }
+    if (schema.maxLength !== void 0) {
+      converted.maxLength = schema.maxLength;
+    }
+    if (schema.pattern !== void 0) {
+      converted.pattern = schema.pattern;
+    }
+    return converted;
+  }
+  /**
+   * Parse response
+   */
+  parseResponse(response) {
+    let content = "";
+    let toolCalls;
+    try {
+      content = response.text();
+    } catch {
+    }
+    const functionCalls = response.functionCalls?.();
+    if (functionCalls && functionCalls.length > 0) {
+      toolCalls = functionCalls.map((fc, index) => ({
+        id: `call_${index}`,
+        name: fc.name,
+        arguments: JSON.stringify(fc.args)
+      }));
+    }
+    if (!toolCalls && response.candidates) {
+      for (const candidate of response.candidates) {
+        for (const part of candidate.content.parts) {
+          if (part.functionCall) {
+            if (!toolCalls) {
+              toolCalls = [];
+            }
+            toolCalls.push({
+              id: `call_${toolCalls.length}`,
+              name: part.functionCall.name,
+              arguments: JSON.stringify(part.functionCall.args)
+            });
+          }
+        }
+      }
+    }
+    return {
+      content,
+      usage: response.usageMetadata ? {
+        promptTokens: response.usageMetadata.promptTokenCount,
+        completionTokens: response.usageMetadata.candidatesTokenCount,
+        totalTokens: response.usageMetadata.totalTokenCount
+      } : void 0,
+      finishReason: response.candidates?.[0]?.finishReason,
+      toolCalls,
+      raw: response
+    };
+  }
+};
+function createGoogleAdapter(client, options) {
+  return new GoogleAdapter(client, options);
+}
+var StructuredProvider = class {
+  clients;
+  adapters;
+  options;
+  defaultProviderName = null;
+  constructor(options = {}) {
+    this.clients = /* @__PURE__ */ new Map();
+    this.adapters = /* @__PURE__ */ new Map();
+    this.options = {
+      enableFixHints: true,
+      validatePartials: false,
+      maxRetries: 3,
+      ...options
+    };
+  }
+  /**
+   * Register a provider client
+   */
+  registerProvider(name, agentSeaClient, setAsDefault = false) {
+    const adapter = this.createAdapter(agentSeaClient);
+    this.adapters.set(name, adapter);
+    const client = new StructuredClient(adapter, {
+      defaultMode: this.options.defaultMode,
+      enableFixHints: this.options.enableFixHints,
+      validatePartials: this.options.validatePartials,
+      defaultRetry: {
+        maxAttempts: this.options.maxRetries ?? 3,
+        retryOn: ["validation_error", "parse_error"]
+      }
+    });
+    this.clients.set(name, client);
+    if (setAsDefault || !this.defaultProviderName) {
+      this.defaultProviderName = name;
+    }
+    return this;
+  }
+  /**
+   * Get a structured client
+   */
+  getClient(name) {
+    const providerName = name ?? this.defaultProviderName;
+    if (!providerName) {
+      throw new Error("No provider registered");
+    }
+    const client = this.clients.get(providerName);
+    if (!client) {
+      throw new Error(`Provider '${providerName}' not found`);
+    }
+    return client;
+  }
+  /**
+   * Extract structured data
+   */
+  async extract(schema, prompt, options) {
+    const client = this.getClient(options?.provider);
+    const messages = Array.isArray(prompt) ? prompt : [{ role: "user", content: prompt }];
+    return client.extract({
+      model: options?.model ?? this.options.defaultModel ?? "gpt-4o",
+      messages,
+      response_format: schema,
+      mode: options?.mode ?? this.options.defaultMode
+    });
+  }
+  /**
+   * Extract structured data with streaming
+   */
+  extractStream(schema, prompt, options) {
+    const client = this.getClient(options?.provider);
+    const messages = Array.isArray(prompt) ? prompt : [{ role: "user", content: prompt }];
+    return client.extractStream(
+      {
+        model: options?.model ?? this.options.defaultModel ?? "gpt-4o",
+        messages,
+        response_format: schema,
+        mode: options?.mode ?? this.options.defaultMode
+      },
+      options?.streaming
+    );
+  }
+  /**
+   * Create a typed extractor for reuse
+   */
+  createExtractor(schema, options) {
+    return new TypedExtractor(this, schema, options);
+  }
+  /**
+   * Create adapter from AgentSea client
+   */
+  createAdapter(agentSeaClient) {
+    switch (agentSeaClient.provider) {
+      case "openai":
+        return new OpenAIAdapter(
+          agentSeaClient.client
+        );
+      case "anthropic":
+        return new AnthropicAdapter(
+          agentSeaClient.client
+        );
+      case "google":
+        return new GoogleAdapter(
+          agentSeaClient.client
+        );
+      default:
+        throw new Error(
+          `Unsupported provider: ${agentSeaClient.provider}`
+        );
+    }
+  }
+};
+var TypedExtractor = class {
+  constructor(provider, schema, options) {
+    this.provider = provider;
+    this.schema = schema;
+    this.options = options;
+  }
+  /**
+   * Extract structured data
+   */
+  async extract(prompt, overrideOptions) {
+    return this.provider.extract(this.schema, prompt, {
+      ...this.options,
+      ...overrideOptions
+    });
+  }
+  /**
+   * Extract with streaming
+   */
+  extractStream(prompt, streamingOptions) {
+    return this.provider.extractStream(this.schema, prompt, {
+      ...this.options,
+      streaming: streamingOptions
+    });
+  }
+  /**
+   * Get the schema
+   */
+  getSchema() {
+    return this.schema;
+  }
+};
+function createStructuredProvider(options) {
+  return new StructuredProvider(options);
+}
+var Extractors = {
+  /**
+   * Create a list extractor
+   */
+  list(itemSchema, options) {
+    let schema = z.array(itemSchema);
+    if (options?.minItems !== void 0) {
+      schema = schema.min(options.minItems);
+    }
+    if (options?.maxItems !== void 0) {
+      schema = schema.max(options.maxItems);
+    }
+    return schema;
+  },
+  /**
+   * Create an entity extractor
+   */
+  entity(shape) {
+    return z.object(shape);
+  },
+  /**
+   * Create a classification extractor
+   */
+  classification(categories, options) {
+    if (options?.confidence) {
+      return z.object({
+        category: z.enum(categories),
+        confidence: z.number().min(0).max(1),
+        reasoning: z.string().optional()
+      });
+    }
+    return z.object({
+      category: z.enum(categories)
+    });
+  },
+  /**
+   * Create a sentiment analyzer
+   */
+  sentiment() {
+    return z.object({
+      sentiment: z.enum(["positive", "negative", "neutral", "mixed"]),
+      score: z.number().min(-1).max(1),
+      aspects: z.array(
+        z.object({
+          aspect: z.string(),
+          sentiment: z.enum(["positive", "negative", "neutral"])
+        })
+      ).optional()
+    });
+  },
+  /**
+   * Create a key-value extractor
+   */
+  keyValue() {
+    return z.record(z.string(), z.unknown());
+  },
+  /**
+   * Create a summary extractor
+   */
+  summary(options) {
+    let summarySchema = z.string();
+    if (options?.maxLength) {
+      summarySchema = summarySchema.max(options.maxLength);
+    }
+    return z.object({
+      summary: summarySchema,
+      keyPoints: z.array(z.string()),
+      entities: z.array(
+        z.object({
+          name: z.string(),
+          type: z.string()
+        })
+      ).optional()
+    });
+  }
+};
+
+// src/types/core.types.ts
+var StructuredError = class extends Error {
+  /** Error code */
+  code;
+  /** Extraction attempts */
+  attempts;
+  /** Last validation errors */
+  validationErrors;
+  /** Partial result if available */
+  partial;
+  constructor(message, code, attempts, validationErrors, partial) {
+    super(message);
+    this.name = "StructuredError";
+    this.code = code;
+    this.attempts = attempts;
+    this.validationErrors = validationErrors;
+    this.partial = partial;
+  }
+};
+
+export { AnthropicAdapter, Extractors, GoogleAdapter, IncrementalJsonParser, OpenAIAdapter, SchemaPromptGenerator, SchemaValidator, StructuredClient, StructuredError, StructuredProvider, TypedExtractor, analyzeSchema, coerceToSchema, createAnthropicAdapter, createGoogleAdapter, createOpenAIAdapter, createStreamingResult, createStructuredClient, createStructuredProvider, extractFieldInfo, formatZodErrors, generateExample, getPartialState, getValidationHints, matchesSchema, schemaToPrompt, tokenizeJson, validatePartial, validateSchema, validateSchemaOrThrow, zodToJsonSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map