@modelrelay/sdk 8.1.0 → 9.0.0

package/dist/chunk-AQJ4VKNC.js

@@ -0,0 +1,1199 @@
+// src/errors.ts
+var ErrorCodes = {
+  NOT_FOUND: "NOT_FOUND",
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  RATE_LIMIT: "RATE_LIMIT",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  CONFLICT: "CONFLICT",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+  INVALID_INPUT: "INVALID_INPUT",
+  PAYMENT_REQUIRED: "PAYMENT_REQUIRED",
+  METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED"
+};
+var ModelRelayError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = this.constructor.name;
+    this.category = opts.category;
+    this.status = opts.status;
+    this.code = opts.code;
+    this.requestId = opts.requestId;
+    this.fields = opts.fields;
+    this.data = opts.data;
+    this.retries = opts.retries;
+    this.cause = opts.cause;
+  }
+};
+var ConfigError = class extends ModelRelayError {
+  constructor(message, data) {
+    super(message, { category: "config", status: 400, data });
+  }
+};
+var TransportError = class extends ModelRelayError {
+  constructor(message, opts) {
+    super(message, {
+      category: "transport",
+      status: opts.kind === "timeout" ? 408 : 0,
+      retries: opts.retries,
+      cause: opts.cause,
+      data: opts.cause
+    });
+    this.kind = opts.kind;
+  }
+};
+var StreamProtocolError = class extends TransportError {
+  constructor(opts) {
+    const got = opts.receivedContentType?.trim() || "<missing>";
+    super(`expected NDJSON stream (${opts.expectedContentType}), got Content-Type ${got}`, {
+      kind: "request"
+    });
+    this.expectedContentType = opts.expectedContentType;
+    this.receivedContentType = opts.receivedContentType?.trim() || void 0;
+    this.status = opts.status;
+  }
+};
+var StreamTimeoutError = class extends ModelRelayError {
+  constructor(streamKind, timeoutMs) {
+    const label = streamKind === "ttft" ? "TTFT" : streamKind === "idle" ? "idle" : "total";
+    super(`stream ${label} timeout after ${timeoutMs}ms`, { category: "transport", status: 408 });
+    this.kind = streamKind;
+    this.timeoutMs = timeoutMs;
+  }
+};
+var APIError = class extends ModelRelayError {
+  constructor(message, opts) {
+    super(message, {
+      category: "api",
+      status: opts.status,
+      code: opts.code,
+      requestId: opts.requestId,
+      fields: opts.fields,
+      data: opts.data,
+      retries: opts.retries
+    });
+  }
+  /** Returns true if the error is a not found error. */
+  isNotFound() {
+    return this.code === ErrorCodes.NOT_FOUND;
+  }
+  /** Returns true if the error is a validation error. */
+  isValidation() {
+    return this.code === ErrorCodes.VALIDATION_ERROR || this.code === ErrorCodes.INVALID_INPUT;
+  }
+  /** Returns true if the error is a rate limit error. */
+  isRateLimit() {
+    return this.code === ErrorCodes.RATE_LIMIT;
+  }
+  /** Returns true if the error is an unauthorized error. */
+  isUnauthorized() {
+    return this.code === ErrorCodes.UNAUTHORIZED;
+  }
+  /** Returns true if the error is a forbidden error. */
+  isForbidden() {
+    return this.code === ErrorCodes.FORBIDDEN;
+  }
+  /** Returns true if the error is a service unavailable error. */
+  isUnavailable() {
+    return this.code === ErrorCodes.SERVICE_UNAVAILABLE;
+  }
+};
+var WorkflowValidationError = class extends ModelRelayError {
+  constructor(opts) {
+    const msg = opts.issues.length === 0 ? "workflow validation error" : opts.issues[0]?.message || "workflow validation error";
+    super(msg, {
+      category: "api",
+      status: opts.status,
+      requestId: opts.requestId,
+      data: opts.data,
+      retries: opts.retries
+    });
+    this.issues = opts.issues;
+  }
+};
+var ToolArgumentError = class extends ModelRelayError {
+  constructor(opts) {
+    super(opts.message, {
+      category: "config",
+      status: 400,
+      cause: opts.cause
+    });
+    this.toolCallId = opts.toolCallId;
+    this.toolName = opts.toolName;
+    this.rawArguments = opts.rawArguments;
+  }
+};
+var PathEscapeError = class extends ModelRelayError {
+  constructor(opts) {
+    super(`path escapes sandbox: ${opts.requestedPath}`, {
+      category: "config",
+      status: 403
+    });
+    this.requestedPath = opts.requestedPath;
+    this.resolvedPath = opts.resolvedPath;
+  }
+};
+var AgentMaxTurnsError = class extends ModelRelayError {
+  constructor(maxTurns) {
+    super(`agent exceeded maximum turns (${maxTurns}) without completing`, {
+      category: "config",
+      status: 400
+    });
+    this.maxTurns = maxTurns;
+  }
+};
+async function parseErrorResponse(response, retries) {
+  const requestId = response.headers.get("X-ModelRelay-Request-Id") || response.headers.get("X-Request-Id") || void 0;
+  const fallbackMessage = response.statusText || "Request failed";
+  const status = response.status || 500;
+  let bodyText = "";
+  let bodyReadErr;
+  try {
+    bodyText = await response.text();
+  } catch (err) {
+    bodyReadErr = err;
+  }
+  if (!bodyText) {
+    return new APIError(fallbackMessage, {
+      status,
+      requestId,
+      retries,
+      data: bodyReadErr ? {
+        body_read_error: bodyReadErr instanceof Error ? bodyReadErr.message : String(bodyReadErr)
+      } : void 0
+    });
+  }
+  try {
+    const parsed = JSON.parse(bodyText);
+    const parsedObj = typeof parsed === "object" && parsed !== null ? parsed : null;
+    const issues = Array.isArray(parsedObj?.issues) ? parsedObj?.issues : null;
+    if (status === 400 && issues && issues.length > 0) {
+      const normalized = [];
+      for (const raw of issues) {
+        if (!raw || typeof raw !== "object") continue;
+        const obj = raw;
+        const code = typeof obj.code === "string" ? obj.code : "";
+        const path = typeof obj.path === "string" ? obj.path : "";
+        const message = typeof obj.message === "string" ? obj.message : "";
+        if (!code || !path || !message) continue;
+        normalized.push({ code, path, message });
+      }
+      if (normalized.length > 0) {
+        return new WorkflowValidationError({
+          status,
+          requestId,
+          issues: normalized,
+          retries,
+          data: parsed
+        });
+      }
+    }
+    if (parsedObj?.error && typeof parsedObj.error === "object") {
+      const errPayload = parsedObj.error;
+      const message = errPayload?.message || fallbackMessage;
+      const code = errPayload?.code || void 0;
+      const fields = Array.isArray(errPayload?.fields) ? errPayload?.fields : void 0;
+      const parsedStatus = typeof errPayload?.status === "number" ? errPayload.status : status;
+      return new APIError(message, {
+        status: parsedStatus,
+        code,
+        fields,
+        requestId: parsedObj?.request_id || parsedObj?.requestId || requestId,
+        data: parsed,
+        retries
+      });
+    }
+    if (parsedObj?.message || parsedObj?.code) {
+      const message = parsedObj.message || fallbackMessage;
+      return new APIError(message, {
+        status,
+        code: parsedObj.code,
+        fields: parsedObj.fields,
+        requestId: parsedObj?.request_id || parsedObj?.requestId || requestId,
+        data: parsed,
+        retries
+      });
+    }
+    return new APIError(fallbackMessage, {
+      status,
+      requestId,
+      data: parsed,
+      retries
+    });
+  } catch {
+    return new APIError(bodyText, { status, requestId, retries });
+  }
+}
+
+// package.json
+var package_default = {
+  name: "@modelrelay/sdk",
+  version: "9.0.0",
+  description: "TypeScript SDK for the ModelRelay API",
+  type: "module",
+  main: "dist/index.cjs",
+  module: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    },
+    "./billing": {
+      types: "./dist/billing/index.d.ts",
+      import: "./dist/billing/index.js",
+      require: "./dist/billing/index.cjs"
+    },
+    "./node": {
+      types: "./dist/node.d.ts",
+      import: "./dist/node.js",
+      require: "./dist/node.cjs"
+    }
+  },
+  publishConfig: {
+    access: "public"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "tsup src/index.ts src/node.ts src/billing/index.ts --format esm,cjs --dts --external playwright",
+    dev: "tsup src/index.ts src/node.ts src/billing/index.ts --format esm,cjs --dts --watch",
+    lint: "tsc --noEmit --project tsconfig.lint.json",
+    test: "vitest run",
+    "generate:types": "openapi-typescript ../../api/openapi/api.json -o src/generated/api.ts"
+  },
+  keywords: [
+    "modelrelay",
+    "llm",
+    "sdk",
+    "typescript"
+  ],
+  author: "Shane Vitarana",
+  license: "Apache-2.0",
+  dependencies: {
+    "fast-json-patch": "^3.1.1",
+    zod: "^3.25.76"
+  },
+  peerDependencies: {
+    "better-sqlite3": "^9.6.0",
+    playwright: ">=1.40.0"
+  },
+  peerDependenciesMeta: {
+    "better-sqlite3": {
+      optional: true
+    },
+    playwright: {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/node": "^25.0.3",
+    "openapi-typescript": "^7.10.1",
+    playwright: "^1.57.0",
+    tsup: "^8.5.1",
+    typescript: "^5.9.3",
+    vitest: "^2.1.9"
+  }
+};
+
+// src/types.ts
+var SDK_VERSION = package_default.version || "0.0.0";
+var DEFAULT_BASE_URL = "https://api.modelrelay.ai/api/v1";
+var DEFAULT_CLIENT_HEADER = `modelrelay-ts/${SDK_VERSION}`;
+var DEFAULT_CONNECT_TIMEOUT_MS = 5e3;
+var DEFAULT_REQUEST_TIMEOUT_MS = 6e4;
+var StopReasons = {
+  Completed: "completed",
+  Stop: "stop",
+  StopSequence: "stop_sequence",
+  EndTurn: "end_turn",
+  MaxTokens: "max_tokens",
+  MaxLength: "max_len",
+  MaxContext: "max_context",
+  ToolCalls: "tool_calls",
+  TimeLimit: "time_limit",
+  ContentFilter: "content_filter",
+  Incomplete: "incomplete",
+  Unknown: "unknown"
+};
+function asProviderId(value) {
+  return value;
+}
+function asModelId(value) {
+  return value;
+}
+function asTierCode(value) {
+  return value;
+}
+var SubscriptionStatuses = {
+  Active: "active",
+  Trialing: "trialing",
+  PastDue: "past_due",
+  Canceled: "canceled",
+  Unpaid: "unpaid",
+  Incomplete: "incomplete",
+  IncompleteExpired: "incomplete_expired",
+  Paused: "paused"
+};
+var BillingProviders = {
+  Stripe: "stripe",
+  Crypto: "crypto",
+  AppStore: "app_store",
+  External: "external"
+};
+function createUsage(inputTokens, outputTokens, totalTokens) {
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: totalTokens ?? inputTokens + outputTokens
+  };
+}
+var MessageRoles = {
+  User: "user",
+  Assistant: "assistant",
+  System: "system",
+  Tool: "tool"
+};
+var ContentPartTypes = {
+  Text: "text"
+};
+var InputItemTypes = {
+  Message: "message"
+};
+var OutputItemTypes = {
+  Message: "message"
+};
+var ToolTypes = {
+  Function: "function",
+  XSearch: "x_search",
+  CodeExecution: "code_execution"
+};
+var ToolChoiceTypes = {
+  Auto: "auto",
+  Required: "required",
+  None: "none"
+};
+var OutputFormatTypes = {
+  Text: "text",
+  JsonSchema: "json_schema"
+};
+function mergeMetrics(base, override) {
+  if (!base && !override) return void 0;
+  return {
+    ...base || {},
+    ...override || {}
+  };
+}
+function mergeTrace(base, override) {
+  if (!base && !override) return void 0;
+  return {
+    ...base || {},
+    ...override || {}
+  };
+}
+function normalizeStopReason(value) {
+  if (value === void 0 || value === null) return void 0;
+  const str = String(value).trim();
+  const lower = str.toLowerCase();
+  for (const reason of Object.values(StopReasons)) {
+    if (lower === reason) return reason;
+  }
+  switch (lower) {
+    case "length":
+      return StopReasons.MaxLength;
+    default:
+      return { other: str };
+  }
+}
+function stopReasonToString(value) {
+  if (!value) return void 0;
+  if (typeof value === "string") return value;
+  return value.other?.trim() || void 0;
+}
+function normalizeModelId(value) {
+  if (value === void 0 || value === null) return void 0;
+  const str = String(value).trim();
+  if (!str) return void 0;
+  return str;
+}
+function modelToString(value) {
+  return String(value).trim();
+}
+
+// src/tools.ts
+function createUserMessage(content) {
+  return {
+    type: "message",
+    role: "user",
+    content: [{ type: "text", text: content }]
+  };
+}
+function createAssistantMessage(content) {
+  return {
+    type: "message",
+    role: "assistant",
+    content: [{ type: "text", text: content }]
+  };
+}
+function createSystemMessage(content) {
+  return {
+    type: "message",
+    role: "system",
+    content: [{ type: "text", text: content }]
+  };
+}
+function createToolCall(id, name, args, type = ToolTypes.Function) {
+  return {
+    id,
+    type,
+    function: createFunctionCall(name, args)
+  };
+}
+function createFunctionCall(name, args) {
+  return { name, arguments: args };
+}
+function zodToJsonSchema(schema, options = {}) {
+  const result = convertZodType(schema);
+  if (options.includeSchema) {
+    const schemaVersion = options.target === "draft-04" ? "http://json-schema.org/draft-04/schema#" : options.target === "draft-2019-09" ? "https://json-schema.org/draft/2019-09/schema" : options.target === "draft-2020-12" ? "https://json-schema.org/draft/2020-12/schema" : "http://json-schema.org/draft-07/schema#";
+    return { $schema: schemaVersion, ...result };
+  }
+  return result;
+}
+function convertZodType(schema) {
+  const def = schema._def;
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return convertZodString(def);
+    case "ZodNumber":
+      return convertZodNumber(def);
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodNull":
+      return { type: "null" };
+    case "ZodArray":
+      return convertZodArray(def);
+    case "ZodObject":
+      return convertZodObject(def);
+    case "ZodEnum":
+      return convertZodEnum(def);
+    case "ZodNativeEnum":
+      return convertZodNativeEnum(def);
+    case "ZodLiteral":
+      return { const: def.value };
+    case "ZodUnion":
+      return convertZodUnion(def);
+    case "ZodOptional": {
+      const inner = convertZodType(def.innerType);
+      if (def.description && !inner.description) {
+        inner.description = def.description;
+      }
+      return inner;
+    }
+    case "ZodNullable":
+      return convertZodNullable(def);
+    case "ZodDefault":
+      return {
+        ...convertZodType(def.innerType),
+        default: def.defaultValue()
+      };
+    case "ZodEffects":
+      return convertZodType(def.schema);
+    case "ZodRecord":
+      return convertZodRecord(def);
+    case "ZodTuple":
+      return convertZodTuple(def);
+    case "ZodAny":
+    case "ZodUnknown":
+      return {};
+    default:
+      throw new ConfigError(
+        `sdk: unsupported Zod schema type ${JSON.stringify(typeName)}; pass JSON Schema directly or use a full converter like zod-to-json-schema`,
+        { typeName }
+      );
+  }
+}
+function convertZodString(def) {
+  const result = { type: "string" };
+  const checks = def.checks;
+  if (checks) {
+    for (const check of checks) {
+      switch (check.kind) {
+        case "min":
+          result.minLength = check.value;
+          break;
+        case "max":
+          result.maxLength = check.value;
+          break;
+        case "length":
+          result.minLength = check.value;
+          result.maxLength = check.value;
+          break;
+        case "email":
+          result.format = "email";
+          break;
+        case "url":
+          result.format = "uri";
+          break;
+        case "uuid":
+          result.format = "uuid";
+          break;
+        case "datetime":
+          result.format = "date-time";
+          break;
+        case "regex":
+          result.pattern = check.value.source;
+          break;
+      }
+    }
+  }
+  if (def.description) {
+    result.description = def.description;
+  }
+  return result;
+}
+function convertZodNumber(def) {
+  const result = { type: "number" };
+  const checks = def.checks;
+  if (checks) {
+    for (const check of checks) {
+      switch (check.kind) {
+        case "int":
+          result.type = "integer";
+          break;
+        case "min":
+          if (check.inclusive === false) {
+            result.exclusiveMinimum = check.value;
+          } else {
+            result.minimum = check.value;
+          }
+          break;
+        case "max":
+          if (check.inclusive === false) {
+            result.exclusiveMaximum = check.value;
+          } else {
+            result.maximum = check.value;
+          }
+          break;
+        case "multipleOf":
+          result.multipleOf = check.value;
+          break;
+      }
+    }
+  }
+  if (def.description) {
+    result.description = def.description;
+  }
+  return result;
+}
+function convertZodArray(def) {
+  const result = {
+    type: "array",
+    items: convertZodType(def.type)
+  };
+  if (def.minLength !== void 0 && def.minLength !== null) {
+    result.minItems = def.minLength.value;
+  }
+  if (def.maxLength !== void 0 && def.maxLength !== null) {
+    result.maxItems = def.maxLength.value;
+  }
+  if (def.description) {
+    result.description = def.description;
+  }
+  return result;
+}
+function convertZodObject(def) {
+  const shape = def.shape;
+  const shapeObj = typeof shape === "function" ? shape() : shape;
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(shapeObj)) {
+    properties[key] = convertZodType(value);
+    const valueDef = value._def;
+    const isOptional = valueDef.typeName === "ZodOptional" || valueDef.typeName === "ZodDefault" || valueDef.typeName === "ZodNullable" && valueDef.innerType?._def?.typeName === "ZodDefault";
+    if (!isOptional) {
+      required.push(key);
+    }
+  }
+  const result = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    result.required = required;
+  }
+  if (def.description) {
+    result.description = def.description;
+  }
+  const unknownKeys = def.unknownKeys;
+  if (unknownKeys === "strict") {
+    result.additionalProperties = false;
+  }
+  return result;
+}
+function convertZodEnum(def) {
+  const result = {
+    type: "string",
+    enum: def.values
+  };
+  if (def.description) {
+    result.description = def.description;
+  }
+  return result;
+}
+function convertZodNativeEnum(def) {
+  const enumValues = def.values;
+  const values = Object.values(enumValues).filter(
+    (v) => typeof v === "string" || typeof v === "number"
+  );
+  const result = { enum: values };
+  if (def.description) {
+    result.description = def.description;
+  }
+  return result;
+}
+function convertZodUnion(def) {
+  const options = def.options;
+  const result = {
+    anyOf: options.map(convertZodType)
+  };
+  if (def.description) {
+    result.description = def.description;
+  }
+  return result;
+}
+function convertZodNullable(def) {
+  const inner = convertZodType(def.innerType);
+  return {
+    anyOf: [inner, { type: "null" }]
+  };
+}
+function convertZodRecord(def) {
+  const result = {
+    type: "object",
+    additionalProperties: convertZodType(def.valueType)
+  };
+  if (def.description) {
+    result.description = def.description;
+  }
+  return result;
+}
+function convertZodTuple(def) {
+  const items = def.items;
+  const result = {
+    type: "array",
+    items: items.map(convertZodType),
+    minItems: items.length,
+    maxItems: items.length
+  };
+  if (def.description) {
+    result.description = def.description;
+  }
+  return result;
+}
+function createFunctionToolFromSchema(name, description, schema, options) {
+  const jsonSchema = zodToJsonSchema(schema, options);
+  return createFunctionTool(name, description, jsonSchema);
+}
+function createTypedTool(def) {
+  const jsonSchema = zodToJsonSchema(def.parameters, def.options);
+  const tool = createFunctionTool(def.name, def.description, jsonSchema);
+  Object.defineProperty(tool, "_schema", {
+    value: def.parameters,
+    enumerable: false
+  });
+  return tool;
+}
+function createFunctionTool(name, description, parameters) {
+  const fn = { name, description };
+  if (parameters) {
+    fn.parameters = parameters;
+  }
+  return {
+    type: ToolTypes.Function,
+    function: fn
+  };
+}
+function toolChoiceAuto() {
+  return { type: ToolChoiceTypes.Auto };
+}
+function toolChoiceRequired() {
+  return { type: ToolChoiceTypes.Required };
+}
+function toolChoiceNone() {
+  return { type: ToolChoiceTypes.None };
+}
+function hasToolCalls(response) {
+  for (const item of response.output || []) {
+    if (item?.toolCalls?.length) return true;
+  }
+  return false;
+}
+function firstToolCall(response) {
+  for (const item of response.output || []) {
+    const call = item?.toolCalls?.[0];
+    if (call) return call;
+  }
+  return void 0;
+}
+function toolResultMessage(toolCallId, result) {
+  const content = typeof result === "string" ? result : JSON.stringify(result);
+  return {
+    type: "message",
+    role: "tool",
+    toolCallId,
+    content: [{ type: "text", text: content }]
+  };
+}
+function respondToToolCall(call, result) {
+  return toolResultMessage(call.id, result);
+}
+function assistantMessageWithToolCalls(content, toolCalls) {
+  return {
+    type: "message",
+    role: "assistant",
+    content: [{ type: "text", text: content }],
+    toolCalls
+  };
+}
+var ToolCallAccumulator = class {
+  constructor() {
+    this.calls = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Processes a streaming tool call delta.
+   * Returns true if this started a new tool call.
+   */
+  processDelta(delta) {
+    const existing = this.calls.get(delta.index);
+    if (!existing) {
+      this.calls.set(delta.index, {
+        id: delta.id ?? "",
+        type: delta.type ?? ToolTypes.Function,
+        function: {
+          name: delta.function?.name ?? "",
+          arguments: delta.function?.arguments ?? ""
+        }
+      });
+      return true;
+    }
+    if (delta.function) {
+      if (delta.function.name) {
+        existing.function = existing.function ?? { name: "", arguments: "" };
+        existing.function.name = delta.function.name;
+      }
+      if (delta.function.arguments) {
+        existing.function = existing.function ?? { name: "", arguments: "" };
+        existing.function.arguments += delta.function.arguments;
+      }
+    }
+    return false;
+  }
+  /**
+   * Returns all accumulated tool calls in index order.
+   */
+  getToolCalls() {
+    if (this.calls.size === 0) {
+      return [];
+    }
+    const maxIdx = Math.max(...this.calls.keys());
+    const result = [];
+    for (let i = 0; i <= maxIdx; i++) {
+      const call = this.calls.get(i);
+      if (call) {
+        result.push(call);
+      }
+    }
+    return result;
+  }
+  /**
+   * Returns a specific tool call by index, or undefined if not found.
+   */
+  getToolCall(index) {
+    return this.calls.get(index);
+  }
+  /**
+   * Clears all accumulated tool calls.
+   */
+  reset() {
+    this.calls.clear();
+  }
+};
+var ToolArgsError = class extends Error {
+  constructor(message, toolCallId, toolName, rawArguments) {
+    super(message);
+    this.name = "ToolArgsError";
+    this.toolCallId = toolCallId;
+    this.toolName = toolName;
+    this.rawArguments = rawArguments;
+  }
+};
+function parseToolArgsWithSchema(call, schema) {
+  const toolName = call.function?.name ?? "unknown";
+  const rawArgs = call.function?.arguments ?? "";
+  let parsed;
+  try {
+    parsed = rawArgs ? JSON.parse(rawArgs) : {};
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Invalid JSON in arguments";
+    throw new ToolArgsError(
+      `Failed to parse arguments for tool '${toolName}': ${message}`,
+      call.id,
+      toolName,
+      rawArgs
+    );
+  }
+  try {
+    return schema.parse(parsed);
+  } catch (err) {
+    let message;
+    if (err instanceof Error) {
+      const zodErr = err;
+      if (zodErr.errors && Array.isArray(zodErr.errors)) {
+        const issues = zodErr.errors.map((e) => {
+          const path = e.path.length > 0 ? `${e.path.join(".")}: ` : "";
+          return `${path}${e.message}`;
+        }).join("; ");
+        message = issues;
+      } else {
+        message = err.message;
+      }
+    } else {
+      message = String(err);
+    }
+    throw new ToolArgsError(
+      `Invalid arguments for tool '${toolName}': ${message}`,
+      call.id,
+      toolName,
+      rawArgs
+    );
+  }
+}
+function parseTypedToolCall(call, tool) {
+  if (!call.function) {
+    throw new ToolArgsError(
+      "Tool call missing function",
+      call.id,
+      tool.function.name,
+      ""
+    );
+  }
+  if (call.function.name !== tool.function.name) {
+    throw new ToolArgsError(
+      `Expected tool '${tool.function.name}', got '${call.function.name}'`,
+      call.id,
+      tool.function.name,
+      call.function.arguments ?? ""
+    );
+  }
+  const parsed = parseToolArgsWithSchema(call, tool._schema);
+  return {
+    ...call,
+    function: {
+      ...call.function,
+      arguments: parsed
+    }
+  };
+}
+function getTypedToolCall(response, tool) {
+  for (const item of response.output || []) {
+    for (const call of item?.toolCalls || []) {
+      if (call.function?.name === tool.function.name) {
+        return parseTypedToolCall(call, tool);
+      }
+    }
+  }
+  return void 0;
+}
+function getTypedToolCalls(response, tool) {
+  const result = [];
+  for (const item of response.output || []) {
+    for (const call of item?.toolCalls || []) {
+      if (call.function?.name === tool.function.name) {
+        result.push(parseTypedToolCall(call, tool));
+      }
+    }
+  }
+  return result;
+}
+function getToolName(call) {
+  return call.function?.name ?? "";
+}
+function getToolArgsRaw(call) {
+  return call.function?.arguments ?? "";
+}
+function getToolArgs(call) {
+  const raw = call.function?.arguments ?? "";
+  if (!raw) return { ok: true, args: {} };
+  try {
+    return { ok: true, args: JSON.parse(raw) };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : "Invalid JSON",
+      raw
+    };
+  }
+}
+function getAllToolCalls(response) {
+  const calls = [];
+  for (const item of response.output || []) {
+    if (item.toolCalls) {
+      calls.push(...item.toolCalls);
+    }
+  }
+  return calls;
+}
+function getAssistantText(response) {
+  const texts = [];
+  for (const item of response.output || []) {
+    if (item.role === "assistant" && item.content) {
+      for (const part of item.content) {
+        if (part.type === "text" && part.text) {
+          texts.push(part.text);
+        }
+      }
+    }
+  }
+  return texts.join("");
+}
+var ToolRegistry = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Registers a handler function for a tool name.
+   * @param name - The tool name (must match the function name in the tool definition)
+   * @param handler - Function to execute when this tool is called
+   * @returns this for chaining
+   */
+  register(name, handler) {
+    this.handlers.set(name, handler);
+    return this;
+  }
+  /**
+   * Unregisters a tool handler.
+   * @param name - The tool name to unregister
+   * @returns true if the handler was removed, false if it didn't exist
+   */
+  unregister(name) {
+    return this.handlers.delete(name);
+  }
+  /**
+   * Checks if a handler is registered for the given tool name.
+   */
+  has(name) {
+    return this.handlers.has(name);
+  }
+  /**
+   * Returns the list of registered tool names.
+   */
+  getRegisteredTools() {
+    return Array.from(this.handlers.keys());
+  }
+  /**
+   * Executes a single tool call.
+   * @param call - The tool call to execute
+   * @returns The execution result
+   */
+  async execute(call) {
+    const toolName = call.function?.name ?? "";
+    const handler = this.handlers.get(toolName);
+    if (!handler) {
+      return {
+        toolCallId: call.id,
+        toolName,
+        result: null,
+        error: `Unknown tool: '${toolName}'. Available tools: ${this.getRegisteredTools().join(", ") || "none"}`
+      };
+    }
+    let args;
+    try {
+      args = call.function?.arguments ? JSON.parse(call.function.arguments) : {};
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      return {
+        toolCallId: call.id,
+        toolName,
+        result: null,
+        error: `Invalid JSON in arguments: ${errorMessage}`,
+        isRetryable: true
+      };
+    }
+    try {
+      const result = await handler(args, call);
+      return {
+        toolCallId: call.id,
+        toolName,
+        result
+      };
+    } catch (err) {
+      const isRetryable = err instanceof ToolArgsError || err instanceof ToolArgumentError;
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      return {
+        toolCallId: call.id,
+        toolName,
+        result: null,
+        error: errorMessage,
+        isRetryable
+      };
+    }
+  }
+  /**
+   * Executes multiple tool calls in parallel.
+   * @param calls - Array of tool calls to execute
+   * @returns Array of execution results in the same order as input
+   */
+  async executeAll(calls) {
+    return Promise.all(calls.map((call) => this.execute(call)));
+  }
+  /**
+   * Converts execution results to tool result messages.
+   * Useful for appending to the conversation history.
+   * @param results - Array of execution results
+   * @returns Array of tool result input items (role "tool")
+   */
+  resultsToMessages(results) {
+    return results.map((r) => {
+      const content = r.error ? `Error: ${r.error}` : typeof r.result === "string" ? r.result : JSON.stringify(r.result);
+      return toolResultMessage(r.toolCallId, content);
+    });
+  }
+};
+function formatToolErrorForModel(result) {
+  const lines = [
+    `Tool call error for '${result.toolName}': ${result.error}`
+  ];
+  if (result.isRetryable) {
+    lines.push("");
+    lines.push("Please correct the arguments and try again.");
+  }
+  return lines.join("\n");
+}
+function hasRetryableErrors(results) {
+  return results.some((r) => r.error && r.isRetryable);
+}
+function getRetryableErrors(results) {
+  return results.filter((r) => r.error && r.isRetryable);
+}
+function createRetryMessages(results) {
+  return results.filter((r) => r.error && r.isRetryable).map((r) => toolResultMessage(r.toolCallId, formatToolErrorForModel(r)));
+}
+async function executeWithRetry(registry, toolCalls, options = {}) {
+  const maxRetries = options.maxRetries ?? 2;
+  let currentCalls = toolCalls;
+  let attempt = 0;
+  const successfulResults = /* @__PURE__ */ new Map();
+  while (attempt <= maxRetries) {
+    const results = await registry.executeAll(currentCalls);
+    for (const result of results) {
+      if (!result.error || !result.isRetryable) {
+        successfulResults.set(result.toolCallId, result);
+      }
+    }
+    const retryableResults = getRetryableErrors(results);
+    if (retryableResults.length === 0 || !options.onRetry) {
+      for (const result of results) {
+        if (result.error && result.isRetryable) {
+          successfulResults.set(result.toolCallId, result);
+        }
+      }
+      return Array.from(successfulResults.values());
+    }
+    attempt++;
+    if (attempt > maxRetries) {
+      for (const result of retryableResults) {
+        successfulResults.set(result.toolCallId, result);
+      }
+      return Array.from(successfulResults.values());
+    }
+    const errorMessages = createRetryMessages(retryableResults);
+    const newCalls = await options.onRetry(errorMessages, attempt);
+    if (newCalls.length === 0) {
+      for (const result of retryableResults) {
+        successfulResults.set(result.toolCallId, result);
+      }
+      return Array.from(successfulResults.values());
+    }
+    currentCalls = newCalls;
+  }
+  return Array.from(successfulResults.values());
+}
+
+export {
+  ErrorCodes,
+  ModelRelayError,
+  ConfigError,
+  TransportError,
+  StreamProtocolError,
+  StreamTimeoutError,
+  APIError,
+  WorkflowValidationError,
+  ToolArgumentError,
+  PathEscapeError,
+  AgentMaxTurnsError,
+  parseErrorResponse,
+  SDK_VERSION,
+  DEFAULT_BASE_URL,
+  DEFAULT_CLIENT_HEADER,
+  DEFAULT_CONNECT_TIMEOUT_MS,
+  DEFAULT_REQUEST_TIMEOUT_MS,
+  StopReasons,
+  asProviderId,
+  asModelId,
+  asTierCode,
+  SubscriptionStatuses,
+  BillingProviders,
+  createUsage,
+  MessageRoles,
+  ContentPartTypes,
+  InputItemTypes,
+  OutputItemTypes,
+  ToolTypes,
+  ToolChoiceTypes,
+  OutputFormatTypes,
+  mergeMetrics,
+  mergeTrace,
+  normalizeStopReason,
+  stopReasonToString,
+  normalizeModelId,
+  modelToString,
+  createUserMessage,
+  createAssistantMessage,
+  createSystemMessage,
+  createToolCall,
+  createFunctionCall,
+  zodToJsonSchema,
+  createFunctionToolFromSchema,
+  createTypedTool,
+  createFunctionTool,
+  toolChoiceAuto,
+  toolChoiceRequired,
+  toolChoiceNone,
+  hasToolCalls,
+  firstToolCall,
+  toolResultMessage,
+  respondToToolCall,
+  assistantMessageWithToolCalls,
+  ToolCallAccumulator,
+  ToolArgsError,
+  parseTypedToolCall,
+  getTypedToolCall,
+  getTypedToolCalls,
+  getToolName,
+  getToolArgsRaw,
+  getToolArgs,
+  getAllToolCalls,
+  getAssistantText,
+  ToolRegistry,
+  formatToolErrorForModel,
+  hasRetryableErrors,
+  getRetryableErrors,
+  createRetryMessages,
+  executeWithRetry
+};