@modelrelay/sdk 0.7.0 → 0.17.0

package/dist/index.js

@@ -1,4 +1,17 @@
 // 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);
@@ -42,6 +55,30 @@ var APIError = class extends ModelRelayError {
       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;
+  }
 };
 async function parseErrorResponse(response, retries) {
   const requestId = response.headers.get("X-ModelRelay-Chat-Request-Id") || response.headers.get("X-Request-Id") || void 0;
@@ -96,6 +133,12 @@ async function parseErrorResponse(response, retries) {
 }
 
 // src/auth.ts
+function createApiKeyAuth(apiKey) {
+  return { apiKey };
+}
+function createAccessTokenAuth(accessToken) {
+  return { accessToken };
+}
 var AuthClient = class {
   constructor(http, cfg) {
     this.cachedFrontend = /* @__PURE__ */ new Map();
@@ -155,7 +198,7 @@ var AuthClient = class {
    */
   async authForChat(customerId, overrides) {
     if (this.accessToken) {
-      return { accessToken: this.accessToken };
+      return createAccessTokenAuth(this.accessToken);
     }
     if (!this.apiKey) {
       throw new ConfigError("API key or token is required");
@@ -166,21 +209,21 @@ var AuthClient = class {
         deviceId: overrides?.deviceId,
         ttlSeconds: overrides?.ttlSeconds
       });
-      return { accessToken: token.token };
+      return createAccessTokenAuth(token.token);
     }
-    return { apiKey: this.apiKey };
+    return createApiKeyAuth(this.apiKey);
   }
   /**
    * Billing calls accept either bearer tokens or API keys (including publishable keys).
    */
   authForBilling() {
     if (this.accessToken) {
-      return { accessToken: this.accessToken };
+      return createAccessTokenAuth(this.accessToken);
     }
     if (!this.apiKey) {
       throw new ConfigError("API key or token is required");
     }
-    return { apiKey: this.apiKey };
+    return createApiKeyAuth(this.apiKey);
   }
 };
 function isPublishableKey(value) {
@@ -218,7 +261,7 @@ function isTokenReusable(token) {
 // package.json
 var package_default = {
   name: "@modelrelay/sdk",
-  version: "0.7.0",
+  version: "0.17.0",
   description: "TypeScript SDK for the ModelRelay API",
   type: "module",
   main: "dist/index.cjs",
@@ -277,36 +320,34 @@ var StopReasons = {
   Incomplete: "incomplete",
   Unknown: "unknown"
 };
-var Providers = {
-  OpenAI: "openai",
-  Anthropic: "anthropic",
-  Grok: "grok",
-  Echo: "echo"
-};
-var Models = {
-  OpenAIGpt4o: "openai/gpt-4o",
-  OpenAIGpt4oMini: "openai/gpt-4o-mini",
-  OpenAIGpt51: "openai/gpt-5.1",
-  AnthropicClaude35HaikuLatest: "anthropic/claude-3-5-haiku-latest",
-  AnthropicClaude35SonnetLatest: "anthropic/claude-3-5-sonnet-latest",
-  AnthropicClaudeOpus45: "anthropic/claude-opus-4-5-20251101",
-  AnthropicClaude35Haiku: "anthropic/claude-3.5-haiku",
-  Grok2: "grok-2",
-  Grok4_1FastNonReasoning: "grok-4-1-fast-non-reasoning",
-  Grok4_1FastReasoning: "grok-4-1-fast-reasoning",
-  Echo1: "echo-1"
-};
+function createUsage(inputTokens, outputTokens, totalTokens) {
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: totalTokens ?? inputTokens + outputTokens
+  };
+}
 var ToolTypes = {
   Function: "function",
+  Web: "web",
   WebSearch: "web_search",
   XSearch: "x_search",
   CodeExecution: "code_execution"
 };
+var WebToolModes = {
+  Search: "search",
+  Browse: "browse"
+};
 var ToolChoiceTypes = {
   Auto: "auto",
   Required: "required",
   None: "none"
 };
+var ResponseFormatTypes = {
+  Text: "text",
+  JsonObject: "json_object",
+  JsonSchema: "json_schema"
+};
 function mergeMetrics(base, override) {
   if (!base && !override) return void 0;
   return {
@@ -340,1631 +381,1917 @@ function stopReasonToString(value) {
   if (typeof value === "string") return value;
   return value.other?.trim() || void 0;
 }
-function normalizeProvider(value) {
-  if (value === void 0 || value === null) return void 0;
-  const str = String(value).trim();
-  if (!str) return void 0;
-  const lower = str.toLowerCase();
-  for (const p of Object.values(Providers)) {
-    if (lower === p) return p;
-  }
-  return { other: str };
-}
-function providerToString(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;
-  const lower = str.toLowerCase();
-  for (const m of Object.values(Models)) {
-    if (lower === m) return m;
-  }
-  return { other: str };
+  return str;
 }
 function modelToString(value) {
-  if (typeof value === "string") return value;
-  return value.other?.trim() || "";
+  return String(value).trim();
 }
 
-// src/chat.ts
-var REQUEST_ID_HEADER = "X-ModelRelay-Chat-Request-Id";
-var ChatClient = class {
-  constructor(http, auth, cfg = {}) {
-    this.completions = new ChatCompletionsClient(
-      http,
-      auth,
-      cfg.defaultMetadata,
-      cfg.metrics,
-      cfg.trace
-    );
-  }
-};
-var ChatCompletionsClient = class {
-  constructor(http, auth, defaultMetadata, metrics, trace) {
-    this.http = http;
-    this.auth = auth;
-    this.defaultMetadata = defaultMetadata;
-    this.metrics = metrics;
-    this.trace = trace;
+// src/tools.ts
+function createUserMessage(content) {
+  return { role: "user", content };
+}
+function createAssistantMessage(content) {
+  return { role: "assistant", content };
+}
+function createSystemMessage(content) {
+  return { role: "system", 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 };
   }
-  async create(params, options = {}) {
-    const stream = options.stream ?? params.stream ?? true;
-    const metrics = mergeMetrics(this.metrics, options.metrics);
-    const trace = mergeTrace(this.trace, options.trace);
-    const modelValue = modelToString(params.model).trim();
-    if (!modelValue) {
-      throw new ConfigError("model is required");
-    }
-    if (!params?.messages?.length) {
-      throw new ConfigError("at least one message is required");
-    }
-    if (!hasUserMessage(params.messages)) {
-      throw new ConfigError("at least one user message is required");
-    }
-    const authHeaders = await this.auth.authForChat(params.customerId);
-    const body = buildProxyBody(
-      params,
-      mergeMetadata(this.defaultMetadata, params.metadata, options.metadata)
-    );
-    const requestId = params.requestId || options.requestId;
-    const headers = { ...options.headers || {} };
-    if (requestId) {
-      headers[REQUEST_ID_HEADER] = requestId;
-    }
-    const baseContext = {
-      method: "POST",
-      path: "/llm/proxy",
-      provider: params.provider,
-      model: params.model,
-      requestId
-    };
-    const response = await this.http.request("/llm/proxy", {
-      method: "POST",
-      body,
-      headers,
-      apiKey: authHeaders.apiKey,
-      accessToken: authHeaders.accessToken,
-      accept: stream ? "text/event-stream" : "application/json",
-      raw: true,
-      signal: options.signal,
-      timeoutMs: options.timeoutMs ?? (stream ? 0 : void 0),
-      useDefaultTimeout: !stream,
-      connectTimeoutMs: options.connectTimeoutMs,
-      retry: options.retry,
-      metrics,
-      trace,
-      context: baseContext
-    });
-    const resolvedRequestId = requestIdFromHeaders(response.headers) || requestId || void 0;
-    if (!response.ok) {
-      throw await parseErrorResponse(response);
-    }
-    if (!stream) {
-      const payload = await response.json();
-      const result = normalizeChatResponse(payload, resolvedRequestId);
-      if (metrics?.usage) {
-        const ctx = {
-          ...baseContext,
-          requestId: resolvedRequestId ?? baseContext.requestId,
-          responseId: result.id
-        };
-        metrics.usage({ usage: result.usage, context: ctx });
+  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 result;
+      return inner;
     }
-    const streamContext = {
-      ...baseContext,
-      requestId: resolvedRequestId ?? baseContext.requestId
-    };
-    return new ChatCompletionsStream(
-      response,
-      resolvedRequestId,
-      streamContext,
-      metrics,
-      trace
-    );
+    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:
+      return {};
   }
-};
-var ChatCompletionsStream = class {
-  constructor(response, requestId, context, metrics, trace) {
-    this.firstTokenEmitted = false;
-    this.closed = false;
-    if (!response.body) {
-      throw new ConfigError("streaming response is missing a body");
+}
+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;
+      }
     }
-    this.response = response;
-    this.requestId = requestId;
-    this.context = context;
-    this.metrics = metrics;
-    this.trace = trace;
-    this.startedAt = this.metrics?.streamFirstToken || this.trace?.streamEvent || this.trace?.streamError ? Date.now() : 0;
   }
-  async cancel(reason) {
-    this.closed = true;
-    try {
-      await this.response.body?.cancel(reason);
-    } catch {
-    }
+  if (def.description) {
+    result.description = def.description;
   }
-  async *[Symbol.asyncIterator]() {
-    if (this.closed) {
-      return;
-    }
-    const body = this.response.body;
-    if (!body) {
-      throw new ConfigError("streaming response is missing a body");
-    }
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        if (this.closed) {
-          await reader.cancel();
-          return;
-        }
-        const { value, done } = await reader.read();
-        if (done) {
-          const { events: events2 } = consumeSSEBuffer(buffer, true);
-          for (const evt of events2) {
-            const parsed = mapChatEvent(evt, this.requestId);
-            if (parsed) {
-              this.handleStreamEvent(parsed);
-              yield parsed;
-            }
+  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;
           }
-          return;
-        }
-        buffer += decoder.decode(value, { stream: true });
-        const { events, remainder } = consumeSSEBuffer(buffer);
-        buffer = remainder;
-        for (const evt of events) {
-          const parsed = mapChatEvent(evt, this.requestId);
-          if (parsed) {
-            this.handleStreamEvent(parsed);
-            yield parsed;
+          break;
+        case "max":
+          if (check.inclusive === false) {
+            result.exclusiveMaximum = check.value;
+          } else {
+            result.maximum = check.value;
           }
-        }
+          break;
+        case "multipleOf":
+          result.multipleOf = check.value;
+          break;
       }
-    } catch (err) {
-      this.recordFirstToken(err);
-      this.trace?.streamError?.({ context: this.context, error: err });
-      throw err;
-    } finally {
-      this.closed = true;
-      reader.releaseLock();
-    }
-  }
-  handleStreamEvent(evt) {
-    const context = this.enrichContext(evt);
-    this.context = context;
-    this.trace?.streamEvent?.({ context, event: evt });
-    if (evt.type === "message_start" || evt.type === "message_delta" || evt.type === "message_stop" || evt.type === "tool_use_start" || evt.type === "tool_use_delta" || evt.type === "tool_use_stop") {
-      this.recordFirstToken();
-    }
-    if (evt.type === "message_stop" && evt.usage && this.metrics?.usage) {
-      this.metrics.usage({ usage: evt.usage, context });
     }
   }
-  enrichContext(evt) {
-    return {
-      ...this.context,
-      responseId: evt.responseId || this.context.responseId,
-      requestId: evt.requestId || this.context.requestId,
-      model: evt.model || this.context.model
-    };
-  }
-  recordFirstToken(error) {
-    if (!this.metrics?.streamFirstToken || this.firstTokenEmitted) return;
-    this.firstTokenEmitted = true;
-    const latencyMs = this.startedAt ? Date.now() - this.startedAt : 0;
-    this.metrics.streamFirstToken({
-      latencyMs,
-      error: error ? String(error) : void 0,
-      context: this.context
-    });
+  if (def.description) {
+    result.description = def.description;
   }
-};
-function consumeSSEBuffer(buffer, flush = false) {
-  const events = [];
-  let eventName = "";
-  let dataLines = [];
-  let remainder = "";
-  const lines = buffer.split(/\r?\n/);
-  const lastIndex = lines.length - 1;
-  const limit = flush ? lines.length : Math.max(0, lastIndex);
-  const pushEvent = () => {
-    if (!eventName && dataLines.length === 0) {
-      return;
-    }
-    events.push({
-      event: eventName || "message",
-      data: dataLines.join("\n")
-    });
-    eventName = "";
-    dataLines = [];
+  return result;
+}
+function convertZodArray(def) {
+  const result = {
+    type: "array",
+    items: convertZodType(def.type)
   };
-  for (let i = 0; i < limit; i++) {
-    const line = lines[i];
-    if (line === "") {
-      pushEvent();
-      continue;
-    }
-    if (line.startsWith(":")) {
-      continue;
-    }
-    if (line.startsWith("event:")) {
-      eventName = line.slice(6).trim();
-    } else if (line.startsWith("data:")) {
-      dataLines.push(line.slice(5).trimStart());
-    }
+  if (def.minLength !== void 0 && def.minLength !== null) {
+    result.minItems = def.minLength.value;
   }
-  if (flush) {
-    pushEvent();
-    remainder = "";
-  } else {
-    remainder = lines[lastIndex] ?? "";
+  if (def.maxLength !== void 0 && def.maxLength !== null) {
+    result.maxItems = def.maxLength.value;
   }
-  return { events, remainder };
+  if (def.description) {
+    result.description = def.description;
+  }
+  return result;
 }
-function mapChatEvent(raw, requestId) {
-  let parsed = raw.data;
-  if (raw.data) {
-    try {
-      parsed = JSON.parse(raw.data);
-    } catch {
-      parsed = raw.data;
+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 payload = typeof parsed === "object" && parsed !== null ? parsed : {};
-  const p = payload;
-  const type = normalizeEventType(raw.event, p);
-  const usage = normalizeUsage(p.usage);
-  const responseId = p.response_id || p.id || p?.message?.id;
-  const model = normalizeModelId(p.model || p?.message?.model);
-  const stopReason = normalizeStopReason(p.stop_reason);
-  const textDelta = extractTextDelta(p);
-  const toolCallDelta = extractToolCallDelta(p, type);
-  const toolCalls = extractToolCalls(p, type);
-  return {
-    type,
-    event: raw.event || type,
-    data: p,
-    textDelta,
-    toolCallDelta,
-    toolCalls,
-    responseId,
-    model,
-    stopReason,
-    usage,
-    requestId,
-    raw: raw.data || ""
+  const result = {
+    type: "object",
+    properties
   };
-}
-function normalizeEventType(eventName, payload) {
-  const hint = String(
-    payload?.type || payload?.event || eventName || ""
-  ).trim();
-  switch (hint) {
-    case "message_start":
-      return "message_start";
-    case "message_delta":
-      return "message_delta";
-    case "message_stop":
-      return "message_stop";
-    case "tool_use_start":
-      return "tool_use_start";
-    case "tool_use_delta":
-      return "tool_use_delta";
-    case "tool_use_stop":
-      return "tool_use_stop";
-    case "ping":
-      return "ping";
-    default:
-      return "custom";
-  }
-}
-function extractTextDelta(payload) {
-  if (!payload || typeof payload !== "object") {
-    return void 0;
+  if (required.length > 0) {
+    result.required = required;
   }
-  if (typeof payload.text_delta === "string" && payload.text_delta !== "") {
-    return payload.text_delta;
+  if (def.description) {
+    result.description = def.description;
   }
-  if (typeof payload.delta === "string") {
-    return payload.delta;
+  const unknownKeys = def.unknownKeys;
+  if (unknownKeys === "strict") {
+    result.additionalProperties = false;
   }
-  if (payload.delta && typeof payload.delta === "object") {
-    if (typeof payload.delta.text === "string") {
-      return payload.delta.text;
-    }
-    if (typeof payload.delta.content === "string") {
-      return payload.delta.content;
-    }
+  return result;
+}
+function convertZodEnum(def) {
+  const result = {
+    type: "string",
+    enum: def.values
+  };
+  if (def.description) {
+    result.description = def.description;
   }
-  return void 0;
+  return result;
 }
-function extractToolCallDelta(payload, type) {
-  if (!payload || typeof payload !== "object") {
-    return void 0;
+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;
   }
-  if (type !== "tool_use_start" && type !== "tool_use_delta") {
-    return void 0;
+  return result;
+}
+function convertZodUnion(def) {
+  const options = def.options;
+  const result = {
+    anyOf: options.map(convertZodType)
+  };
+  if (def.description) {
+    result.description = def.description;
   }
-  if (payload.tool_call_delta) {
-    const d = payload.tool_call_delta;
-    return {
-      index: d.index ?? 0,
-      id: d.id,
-      type: d.type,
-      function: d.function ? {
-        name: d.function.name,
-        arguments: d.function.arguments
-      } : void 0
-    };
-  }
-  if (typeof payload.index === "number" || payload.id || payload.name) {
-    return {
-      index: payload.index ?? 0,
-      id: payload.id,
-      type: payload.tool_type,
-      function: payload.name || payload.arguments ? {
-        name: payload.name,
-        arguments: payload.arguments
-      } : void 0
-    };
-  }
-  return void 0;
+  return result;
 }
-function extractToolCalls(payload, type) {
-  if (!payload || typeof payload !== "object") {
-    return void 0;
-  }
-  if (type !== "tool_use_stop" && type !== "message_stop") {
-    return void 0;
-  }
-  if (payload.tool_calls?.length) {
-    return normalizeToolCalls(payload.tool_calls);
-  }
-  if (payload.tool_call) {
-    return normalizeToolCalls([payload.tool_call]);
+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 void 0;
+  return result;
 }
-function normalizeChatResponse(payload, requestId) {
-  const p = payload;
-  const response = {
-    id: p?.id,
-    provider: normalizeProvider(p?.provider),
-    content: Array.isArray(p?.content) ? p.content : p?.content ? [String(p.content)] : [],
-    stopReason: normalizeStopReason(p?.stop_reason),
-    model: normalizeModelId(p?.model),
-    usage: normalizeUsage(p?.usage),
-    requestId
+function convertZodTuple(def) {
+  const items = def.items;
+  const result = {
+    type: "array",
+    items: items.map(convertZodType),
+    minItems: items.length,
+    maxItems: items.length
   };
-  if (p?.tool_calls?.length) {
-    response.toolCalls = normalizeToolCalls(p.tool_calls);
+  if (def.description) {
+    result.description = def.description;
   }
-  return response;
+  return result;
 }
-function normalizeToolCalls(toolCalls) {
-  return toolCalls.map((tc) => ({
-    id: tc.id,
-    type: tc.type || ToolTypes.Function,
-    function: tc.function ? { name: tc.function.name, arguments: tc.function.arguments } : void 0
-  }));
+function createFunctionToolFromSchema(name, description, schema, options) {
+  const jsonSchema = zodToJsonSchema(schema, options);
+  return createFunctionTool(name, description, jsonSchema);
 }
-function normalizeUsage(payload) {
-  if (!payload) {
-    return { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+function createFunctionTool(name, description, parameters) {
+  const fn = { name, description };
+  if (parameters) {
+    fn.parameters = parameters;
   }
-  const usage = {
-    inputTokens: Number(payload.input_tokens ?? 0),
-    outputTokens: Number(payload.output_tokens ?? 0),
-    totalTokens: Number(payload.total_tokens ?? 0)
+  return {
+    type: ToolTypes.Function,
+    function: fn
   };
-  if (!usage.totalTokens) {
-    usage.totalTokens = usage.inputTokens + usage.outputTokens;
-  }
-  return usage;
 }
-function buildProxyBody(params, metadata) {
-  const body = {
-    model: modelToString(params.model),
-    messages: normalizeMessages(params.messages)
+function createWebTool(options) {
+  return {
+    type: ToolTypes.Web,
+    web: options ? {
+      mode: options.mode,
+      allowedDomains: options.allowedDomains,
+      excludedDomains: options.excludedDomains,
+      maxUses: options.maxUses
+    } : void 0
   };
-  if (typeof params.maxTokens === "number") body.max_tokens = params.maxTokens;
-  if (params.provider) body.provider = providerToString(params.provider);
-  if (typeof params.temperature === "number")
-    body.temperature = params.temperature;
-  if (metadata && Object.keys(metadata).length > 0) body.metadata = metadata;
-  if (params.stop?.length) body.stop = params.stop;
-  if (params.stopSequences?.length) body.stop_sequences = params.stopSequences;
-  if (params.tools?.length) body.tools = normalizeTools(params.tools);
-  if (params.toolChoice) body.tool_choice = normalizeToolChoice(params.toolChoice);
-  return body;
 }
-function normalizeMessages(messages) {
-  return messages.map((msg) => {
-    const normalized = {
-      role: msg.role || "user",
-      content: msg.content
-    };
-    if (msg.toolCalls?.length) {
-      normalized.tool_calls = msg.toolCalls.map((tc) => ({
-        id: tc.id,
-        type: tc.type,
-        function: tc.function ? { name: tc.function.name, arguments: tc.function.arguments } : void 0
-      }));
-    }
-    if (msg.toolCallId) {
-      normalized.tool_call_id = msg.toolCallId;
-    }
-    return normalized;
-  });
+function toolChoiceAuto() {
+  return { type: ToolChoiceTypes.Auto };
 }
-function normalizeTools(tools) {
-  return tools.map((tool) => {
-    const normalized = { type: tool.type };
-    if (tool.function) {
-      normalized.function = {
-        name: tool.function.name,
-        description: tool.function.description,
-        parameters: tool.function.parameters
-      };
-    }
-    if (tool.webSearch) {
-      normalized.web_search = {
-        allowed_domains: tool.webSearch.allowedDomains,
-        excluded_domains: tool.webSearch.excludedDomains,
-        max_uses: tool.webSearch.maxUses
-      };
-    }
-    if (tool.xSearch) {
-      normalized.x_search = {
-        allowed_handles: tool.xSearch.allowedHandles,
-        excluded_handles: tool.xSearch.excludedHandles,
-        from_date: tool.xSearch.fromDate,
-        to_date: tool.xSearch.toDate
-      };
-    }
-    if (tool.codeExecution) {
-      normalized.code_execution = {
-        language: tool.codeExecution.language,
-        timeout_ms: tool.codeExecution.timeoutMs
-      };
-    }
-    return normalized;
-  });
+function toolChoiceRequired() {
+  return { type: ToolChoiceTypes.Required };
 }
-function normalizeToolChoice(tc) {
-  return { type: tc.type };
+function toolChoiceNone() {
+  return { type: ToolChoiceTypes.None };
 }
-function requestIdFromHeaders(headers) {
-  return headers.get(REQUEST_ID_HEADER) || headers.get("X-Request-Id") || void 0;
+function hasToolCalls(response) {
+  return (response.toolCalls?.length ?? 0) > 0;
 }
-function mergeMetadata(...sources) {
-  const merged = {};
-  for (const src of sources) {
-    if (!src) continue;
-    for (const [key, value] of Object.entries(src)) {
-      const k = key?.trim();
-      const v = value?.trim();
-      if (!k || !v) continue;
-      merged[k] = v;
-    }
-  }
-  return Object.keys(merged).length ? merged : void 0;
+function firstToolCall(response) {
+  return response.toolCalls?.[0];
 }
-function hasUserMessage(messages) {
-  return messages.some(
-    (msg) => msg.role?.toLowerCase?.() === "user" && !!msg.content
-  );
+function toolResultMessage(toolCallId, result) {
+  const content = typeof result === "string" ? result : JSON.stringify(result);
+  return {
+    role: "tool",
+    content,
+    toolCallId
+  };
 }
-
-// src/customers.ts
-var CustomersClient = class {
-  constructor(http, cfg) {
-    this.http = http;
-    this.apiKey = cfg.apiKey;
-  }
-  ensureSecretKey() {
-    if (!this.apiKey || !this.apiKey.startsWith("mr_sk_")) {
-      throw new ConfigError(
-        "Secret key (mr_sk_*) required for customer operations"
-      );
-    }
+function respondToToolCall(call, result) {
+  return toolResultMessage(call.id, result);
+}
+function assistantMessageWithToolCalls(content, toolCalls) {
+  return {
+    role: "assistant",
+    content,
+    toolCalls
+  };
+}
+var ToolCallAccumulator = class {
+  constructor() {
+    this.calls = /* @__PURE__ */ new Map();
   }
   /**
-   * List all customers in the project.
+   * Processes a streaming tool call delta.
+   * Returns true if this started a new tool call.
    */
-  async list() {
-    this.ensureSecretKey();
-    const response = await this.http.json("/customers", {
-      method: "GET",
-      apiKey: this.apiKey
-    });
-    return response.customers;
+  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;
   }
   /**
-   * Create a new customer in the project.
+   * Returns all accumulated tool calls in index order.
    */
-  async create(request) {
-    this.ensureSecretKey();
-    if (!request.tier_id?.trim()) {
-      throw new ConfigError("tier_id is required");
-    }
-    if (!request.external_id?.trim()) {
-      throw new ConfigError("external_id is required");
+  getToolCalls() {
+    if (this.calls.size === 0) {
+      return [];
     }
-    const response = await this.http.json("/customers", {
-      method: "POST",
-      body: request,
-      apiKey: this.apiKey
-    });
-    return response.customer;
+    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;
   }
   /**
-   * Get a customer by ID.
+   * Returns a specific tool call by index, or undefined if not found.
    */
-  async get(customerId) {
-    this.ensureSecretKey();
-    if (!customerId?.trim()) {
-      throw new ConfigError("customerId is required");
-    }
-    const response = await this.http.json(
-      `/customers/${customerId}`,
-      {
-        method: "GET",
-        apiKey: this.apiKey
-      }
-    );
-    return response.customer;
+  getToolCall(index) {
+    return this.calls.get(index);
   }
   /**
-   * Upsert a customer by external_id.
-   * If a customer with the given external_id exists, it is updated.
-   * Otherwise, a new customer is created.
+   * Clears all accumulated tool calls.
    */
-  async upsert(request) {
-    this.ensureSecretKey();
-    if (!request.tier_id?.trim()) {
-      throw new ConfigError("tier_id is required");
+  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 parseToolArgs(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);
     }
-    if (!request.external_id?.trim()) {
-      throw new ConfigError("external_id is required");
+    throw new ToolArgsError(
+      `Invalid arguments for tool '${toolName}': ${message}`,
+      call.id,
+      toolName,
+      rawArgs
+    );
+  }
+}
+function tryParseToolArgs(call, schema) {
+  try {
+    const data = parseToolArgs(call, schema);
+    return { success: true, data };
+  } catch (err) {
+    if (err instanceof ToolArgsError) {
+      return { success: false, error: err };
     }
-    const response = await this.http.json("/customers", {
-      method: "PUT",
-      body: request,
-      apiKey: this.apiKey
-    });
-    return response.customer;
+    const toolName = call.function?.name ?? "unknown";
+    const rawArgs = call.function?.arguments ?? "";
+    return {
+      success: false,
+      error: new ToolArgsError(
+        err instanceof Error ? err.message : String(err),
+        call.id,
+        toolName,
+        rawArgs
+      )
+    };
+  }
+}
+function parseToolArgsRaw(call) {
+  const toolName = call.function?.name ?? "unknown";
+  const rawArgs = call.function?.arguments ?? "";
+  try {
+    return 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
+    );
+  }
+}
+var ToolRegistry = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
   }
   /**
-   * Delete a customer by ID.
+   * 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
    */
-  async delete(customerId) {
-    this.ensureSecretKey();
-    if (!customerId?.trim()) {
-      throw new ConfigError("customerId is required");
-    }
-    await this.http.request(`/customers/${customerId}`, {
-      method: "DELETE",
-      apiKey: this.apiKey
-    });
+  register(name, handler) {
+    this.handlers.set(name, handler);
+    return this;
   }
   /**
-   * Create a Stripe checkout session for a customer.
+   * Unregisters a tool handler.
+   * @param name - The tool name to unregister
+   * @returns true if the handler was removed, false if it didn't exist
    */
-  async createCheckoutSession(customerId, request) {
-    this.ensureSecretKey();
-    if (!customerId?.trim()) {
-      throw new ConfigError("customerId is required");
-    }
-    if (!request.success_url?.trim() || !request.cancel_url?.trim()) {
-      throw new ConfigError("success_url and cancel_url are required");
-    }
-    return await this.http.json(
-      `/customers/${customerId}/checkout`,
-      {
-        method: "POST",
-        body: request,
-        apiKey: this.apiKey
-      }
-    );
+  unregister(name) {
+    return this.handlers.delete(name);
   }
   /**
-   * Get the subscription status for a customer.
+   * Checks if a handler is registered for the given tool name.
    */
-  async getSubscription(customerId) {
-    this.ensureSecretKey();
-    if (!customerId?.trim()) {
-      throw new ConfigError("customerId is required");
-    }
-    return await this.http.json(
-      `/customers/${customerId}/subscription`,
-      {
-        method: "GET",
-        apiKey: this.apiKey
-      }
-    );
-  }
-};
-
-// src/tiers.ts
-var TiersClient = class {
-  constructor(http, cfg) {
-    this.http = http;
-    this.apiKey = cfg.apiKey;
-  }
-  ensureApiKey() {
-    if (!this.apiKey || !this.apiKey.startsWith("mr_pk_") && !this.apiKey.startsWith("mr_sk_")) {
-      throw new ConfigError(
-        "API key (mr_pk_* or mr_sk_*) required for tier operations"
-      );
-    }
+  has(name) {
+    return this.handlers.has(name);
   }
   /**
-   * List all tiers in the project.
+   * Returns the list of registered tool names.
    */
-  async list() {
-    this.ensureApiKey();
-    const response = await this.http.json("/tiers", {
-      method: "GET",
-      apiKey: this.apiKey
-    });
-    return response.tiers;
+  getRegisteredTools() {
+    return Array.from(this.handlers.keys());
   }
   /**
-   * Get a tier by ID.
+   * Executes a single tool call.
+   * @param call - The tool call to execute
+   * @returns The execution result
    */
-  async get(tierId) {
-    this.ensureApiKey();
-    if (!tierId?.trim()) {
-      throw new ConfigError("tierId is required");
-    }
-    const response = await this.http.json(`/tiers/${tierId}`, {
-      method: "GET",
-      apiKey: this.apiKey
-    });
-    return response.tier;
-  }
-};
-
-// src/http.ts
-var HTTPClient = class {
-  constructor(cfg) {
-    const resolvedBase = normalizeBaseUrl(cfg.baseUrl || DEFAULT_BASE_URL);
-    if (!isValidHttpUrl(resolvedBase)) {
-      throw new ConfigError(
-        "baseUrl must start with http:// or https://"
-      );
+  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;
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      return {
+        toolCallId: call.id,
+        toolName,
+        result: null,
+        error: errorMessage,
+        isRetryable
+      };
     }
-    this.baseUrl = resolvedBase;
-    this.apiKey = cfg.apiKey?.trim();
-    this.accessToken = cfg.accessToken?.trim();
-    this.fetchImpl = cfg.fetchImpl;
-    this.clientHeader = cfg.clientHeader?.trim() || DEFAULT_CLIENT_HEADER;
-    this.defaultConnectTimeoutMs = cfg.connectTimeoutMs === void 0 ? DEFAULT_CONNECT_TIMEOUT_MS : Math.max(0, cfg.connectTimeoutMs);
-    this.defaultTimeoutMs = cfg.timeoutMs === void 0 ? DEFAULT_REQUEST_TIMEOUT_MS : Math.max(0, cfg.timeoutMs);
-    this.retry = normalizeRetryConfig(cfg.retry);
-    this.defaultHeaders = normalizeHeaders(cfg.defaultHeaders);
-    this.metrics = cfg.metrics;
-    this.trace = cfg.trace;
   }
-  async request(path, options = {}) {
-    const fetchFn = this.fetchImpl ?? globalThis.fetch;
-    if (!fetchFn) {
-      throw new ConfigError(
-        "fetch is not available; provide a fetch implementation"
-      );
+  /**
+   * 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 ChatMessage objects with 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 method = options.method || "GET";
-    const url = buildUrl(this.baseUrl, path);
+    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());
+}
+
+// src/chat.ts
+var REQUEST_ID_HEADER = "X-ModelRelay-Chat-Request-Id";
+var ChatClient = class {
+  constructor(http, auth, cfg = {}) {
+    this.completions = new ChatCompletionsClient(
+      http,
+      auth,
+      cfg.defaultMetadata,
+      cfg.metrics,
+      cfg.trace
+    );
+  }
+};
+var ChatCompletionsClient = class {
+  constructor(http, auth, defaultMetadata, metrics, trace) {
+    this.http = http;
+    this.auth = auth;
+    this.defaultMetadata = defaultMetadata;
+    this.metrics = metrics;
+    this.trace = trace;
+  }
+  async create(params, options = {}) {
+    const stream = options.stream ?? params.stream ?? true;
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
-    const context = {
-      method,
-      path,
-      ...options.context || {}
+    if (!params?.messages?.length) {
+      throw new ConfigError("at least one message is required");
+    }
+    if (!hasUserMessage(params.messages)) {
+      throw new ConfigError("at least one user message is required");
+    }
+    const authHeaders = await this.auth.authForChat(params.customerId);
+    const body = buildProxyBody(
+      params,
+      mergeMetadata(this.defaultMetadata, params.metadata, options.metadata)
+    );
+    const requestId = params.requestId || options.requestId;
+    const headers = { ...options.headers || {} };
+    if (requestId) {
+      headers[REQUEST_ID_HEADER] = requestId;
+    }
+    const baseContext = {
+      method: "POST",
+      path: "/llm/proxy",
+      model: params.model,
+      requestId
     };
-    trace?.requestStart?.(context);
-    const start = metrics?.httpRequest || trace?.requestFinish ? Date.now() : 0;
-    const headers = new Headers({
-      ...this.defaultHeaders,
-      ...options.headers || {}
+    const response = await this.http.request("/llm/proxy", {
+      method: "POST",
+      body,
+      headers,
+      apiKey: authHeaders.apiKey,
+      accessToken: authHeaders.accessToken,
+      accept: stream ? "text/event-stream" : "application/json",
+      raw: true,
+      signal: options.signal,
+      timeoutMs: options.timeoutMs ?? (stream ? 0 : void 0),
+      useDefaultTimeout: !stream,
+      connectTimeoutMs: options.connectTimeoutMs,
+      retry: options.retry,
+      metrics,
+      trace,
+      context: baseContext
     });
-    const accepts = options.accept || (options.raw ? void 0 : "application/json");
-    if (accepts && !headers.has("Accept")) {
-      headers.set("Accept", accepts);
+    const resolvedRequestId = requestIdFromHeaders(response.headers) || requestId || void 0;
+    if (!response.ok) {
+      throw await parseErrorResponse(response);
     }
-    const body = options.body;
-    const shouldEncodeJSON = body !== void 0 && body !== null && typeof body === "object" && !(body instanceof FormData) && !(body instanceof Blob);
-    const payload = shouldEncodeJSON ? JSON.stringify(body) : body;
-    if (shouldEncodeJSON && !headers.has("Content-Type")) {
-      headers.set("Content-Type", "application/json");
+    if (!stream) {
+      const payload = await response.json();
+      const result = normalizeChatResponse(payload, resolvedRequestId);
+      if (metrics?.usage) {
+        const ctx = {
+          ...baseContext,
+          requestId: resolvedRequestId ?? baseContext.requestId,
+          responseId: result.id
+        };
+        metrics.usage({ usage: result.usage, context: ctx });
+      }
+      return result;
     }
-    const accessToken = options.accessToken ?? this.accessToken;
-    if (accessToken) {
-      const bearer = accessToken.toLowerCase().startsWith("bearer ") ? accessToken : `Bearer ${accessToken}`;
-      headers.set("Authorization", bearer);
+    const streamContext = {
+      ...baseContext,
+      requestId: resolvedRequestId ?? baseContext.requestId
+    };
+    return new ChatCompletionsStream(
+      response,
+      resolvedRequestId,
+      streamContext,
+      metrics,
+      trace
+    );
+  }
+  /**
+   * Stream structured JSON responses using the NDJSON contract defined for
+   * /llm/proxy. The request must include a structured responseFormat.
+   */
+  async streamJSON(params, options = {}) {
+    const metrics = mergeMetrics(this.metrics, options.metrics);
+    const trace = mergeTrace(this.trace, options.trace);
+    if (!params?.messages?.length) {
+      throw new ConfigError("at least one message is required");
     }
-    const apiKey = options.apiKey ?? this.apiKey;
-    if (apiKey) {
-      headers.set("X-ModelRelay-Api-Key", apiKey);
+    if (!hasUserMessage(params.messages)) {
+      throw new ConfigError("at least one user message is required");
     }
-    if (this.clientHeader && !headers.has("X-ModelRelay-Client")) {
-      headers.set("X-ModelRelay-Client", this.clientHeader);
+    if (!params.responseFormat || params.responseFormat.type !== "json_object" && params.responseFormat.type !== "json_schema") {
+      throw new ConfigError(
+        "responseFormat with type=json_object or json_schema is required for structured streaming"
+      );
     }
-    const timeoutMs = options.useDefaultTimeout === false ? options.timeoutMs : options.timeoutMs ?? this.defaultTimeoutMs;
-    const connectTimeoutMs = options.useDefaultConnectTimeout === false ? options.connectTimeoutMs : options.connectTimeoutMs ?? this.defaultConnectTimeoutMs;
-    const retryCfg = normalizeRetryConfig(
-      options.retry === void 0 ? this.retry : options.retry
+    const authHeaders = await this.auth.authForChat(params.customerId);
+    const body = buildProxyBody(
+      params,
+      mergeMetadata(this.defaultMetadata, params.metadata, options.metadata)
     );
-    const attempts = retryCfg ? Math.max(1, retryCfg.maxAttempts) : 1;
-    let lastError;
-    let lastStatus;
-    for (let attempt = 1; attempt <= attempts; attempt++) {
-      let connectTimedOut = false;
-      let requestTimedOut = false;
-      const connectController = connectTimeoutMs && connectTimeoutMs > 0 ? new AbortController() : void 0;
-      const requestController = timeoutMs && timeoutMs > 0 ? new AbortController() : void 0;
-      const signal = mergeSignals(
-        options.signal,
-        connectController?.signal,
-        requestController?.signal
-      );
-      const connectTimer = connectController && setTimeout(() => {
-        connectTimedOut = true;
-        connectController.abort(
-          new DOMException("connect timeout", "AbortError")
-        );
-      }, connectTimeoutMs);
-      const requestTimer = requestController && setTimeout(() => {
-        requestTimedOut = true;
-        requestController.abort(
-          new DOMException("timeout", "AbortError")
-        );
-      }, timeoutMs);
-      try {
-        const response = await fetchFn(url, {
-          method,
-          headers,
-          body: payload,
-          signal
-        });
-        if (connectTimer) {
-          clearTimeout(connectTimer);
-        }
-        if (!response.ok) {
-          const shouldRetry = retryCfg && shouldRetryStatus(
-            response.status,
-            method,
-            retryCfg.retryPost
-          ) && attempt < attempts;
-          if (shouldRetry) {
-            lastStatus = response.status;
-            await backoff(attempt, retryCfg);
-            continue;
-          }
-          const retries = buildRetryMetadata(attempt, response.status, lastError);
-          const finishedCtx2 = withRequestId(context, response.headers);
-          recordHttpMetrics(metrics, trace, start, retries, {
-            status: response.status,
-            context: finishedCtx2
-          });
-          throw options.raw ? await parseErrorResponse(response, retries) : await parseErrorResponse(response, retries);
-        }
-        const finishedCtx = withRequestId(context, response.headers);
-        recordHttpMetrics(metrics, trace, start, void 0, {
-          status: response.status,
-          context: finishedCtx
-        });
-        return response;
-      } catch (err) {
-        if (options.signal?.aborted) {
-          throw err;
-        }
-        if (err instanceof ModelRelayError) {
-          recordHttpMetrics(metrics, trace, start, void 0, {
-            error: err,
-            context
-          });
-          throw err;
-        }
-        const transportKind = classifyTransportErrorKind(
-          err,
-          connectTimedOut,
-          requestTimedOut
-        );
-        const shouldRetry = retryCfg && isRetryableError(err, transportKind) && (method !== "POST" || retryCfg.retryPost) && attempt < attempts;
-        if (!shouldRetry) {
-          const retries = buildRetryMetadata(
-            attempt,
-            lastStatus,
-            err instanceof Error ? err.message : String(err)
-          );
-          recordHttpMetrics(metrics, trace, start, retries, {
-            error: err,
-            context
-          });
-          throw toTransportError(err, transportKind, retries);
-        }
-        lastError = err;
-        await backoff(attempt, retryCfg);
-      } finally {
-        if (connectTimer) {
-          clearTimeout(connectTimer);
-        }
-        if (requestTimer) {
-          clearTimeout(requestTimer);
-        }
-      }
+    const requestId = params.requestId || options.requestId;
+    const headers = { ...options.headers || {} };
+    if (requestId) {
+      headers[REQUEST_ID_HEADER] = requestId;
     }
-    throw lastError instanceof Error ? lastError : new TransportError("request failed", {
-      kind: "other",
-      retries: buildRetryMetadata(attempts, lastStatus)
-    });
-  }
-  async json(path, options = {}) {
-    const response = await this.request(path, {
-      ...options,
+    const baseContext = {
+      method: "POST",
+      path: "/llm/proxy",
+      model: params.model,
+      requestId
+    };
+    const response = await this.http.request("/llm/proxy", {
+      method: "POST",
+      body,
+      headers,
+      apiKey: authHeaders.apiKey,
+      accessToken: authHeaders.accessToken,
+      accept: "application/x-ndjson",
       raw: true,
-      accept: options.accept || "application/json"
+      signal: options.signal,
+      timeoutMs: options.timeoutMs ?? 0,
+      useDefaultTimeout: false,
+      connectTimeoutMs: options.connectTimeoutMs,
+      retry: options.retry,
+      metrics,
+      trace,
+      context: baseContext
     });
+    const resolvedRequestId = requestIdFromHeaders(response.headers) || requestId || void 0;
     if (!response.ok) {
       throw await parseErrorResponse(response);
     }
-    if (response.status === 204) {
-      return void 0;
-    }
-    try {
-      return await response.json();
-    } catch (err) {
-      throw new APIError("failed to parse response JSON", {
-        status: response.status,
-        data: err
-      });
+    const contentType = response.headers.get("Content-Type") || "";
+    if (!/application\/(x-)?ndjson/i.test(contentType)) {
+      throw new TransportError(
+        `expected NDJSON structured stream, got Content-Type ${contentType || "missing"}`,
+        { kind: "request" }
+      );
     }
+    const streamContext = {
+      ...baseContext,
+      requestId: resolvedRequestId ?? baseContext.requestId
+    };
+    return new StructuredJSONStream(
+      response,
+      resolvedRequestId,
+      streamContext,
+      metrics,
+      trace
+    );
   }
 };
-function buildUrl(baseUrl, path) {
-  if (/^https?:\/\//i.test(path)) {
-    return path;
-  }
-  if (!path.startsWith("/")) {
-    path = `/${path}`;
-  }
-  return `${baseUrl}${path}`;
-}
-function normalizeBaseUrl(value) {
-  const trimmed = value.trim();
-  if (trimmed.endsWith("/")) {
-    return trimmed.slice(0, -1);
-  }
-  return trimmed;
-}
-function isValidHttpUrl(value) {
-  return /^https?:\/\//i.test(value);
-}
-function normalizeRetryConfig(retry) {
-  if (retry === false) return void 0;
-  const cfg = retry || {};
-  return {
-    maxAttempts: Math.max(1, cfg.maxAttempts ?? 3),
-    baseBackoffMs: Math.max(0, cfg.baseBackoffMs ?? 300),
-    maxBackoffMs: Math.max(0, cfg.maxBackoffMs ?? 5e3),
-    retryPost: cfg.retryPost ?? true
-  };
-}
-function shouldRetryStatus(status, method, retryPost) {
-  if (status === 408 || status === 429) {
-    return method !== "POST" || retryPost;
+var ChatCompletionsStream = class {
+  constructor(response, requestId, context, metrics, trace) {
+    this.firstTokenEmitted = false;
+    this.closed = false;
+    if (!response.body) {
+      throw new ConfigError("streaming response is missing a body");
+    }
+    this.response = response;
+    this.requestId = requestId;
+    this.context = context;
+    this.metrics = metrics;
+    this.trace = trace;
+    this.startedAt = this.metrics?.streamFirstToken || this.trace?.streamEvent || this.trace?.streamError ? Date.now() : 0;
   }
-  if (status >= 500 && status < 600) {
-    return method !== "POST" || retryPost;
+  async cancel(reason) {
+    this.closed = true;
+    try {
+      await this.response.body?.cancel(reason);
+    } catch {
+    }
   }
-  return false;
-}
-function isRetryableError(err, kind) {
-  if (!err) return false;
-  if (kind === "timeout" || kind === "connect") return true;
-  return err instanceof DOMException || err instanceof TypeError;
-}
-function backoff(attempt, cfg) {
-  const exp = Math.max(0, attempt - 1);
-  const base = cfg.baseBackoffMs * Math.pow(2, Math.min(exp, 10));
-  const capped = Math.min(base, cfg.maxBackoffMs);
-  const jitter = 0.5 + Math.random();
-  const delay = Math.min(cfg.maxBackoffMs, capped * jitter);
-  if (delay <= 0) return Promise.resolve();
-  return new Promise((resolve) => setTimeout(resolve, delay));
-}
-function mergeSignals(...signals) {
-  const active = signals.filter(Boolean);
-  if (active.length === 0) return void 0;
-  if (active.length === 1) return active[0];
-  const controller = new AbortController();
-  for (const src of active) {
-    if (src.aborted) {
-      controller.abort(src.reason);
-      break;
+  async *[Symbol.asyncIterator]() {
+    if (this.closed) {
+      return;
+    }
+    const body = this.response.body;
+    if (!body) {
+      throw new ConfigError("streaming response is missing a body");
+    }
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        if (this.closed) {
+          await reader.cancel();
+          return;
+        }
+        const { value, done } = await reader.read();
+        if (done) {
+          const { events: events2 } = consumeSSEBuffer(buffer, true);
+          for (const evt of events2) {
+            const parsed = mapChatEvent(evt, this.requestId);
+            if (parsed) {
+              this.handleStreamEvent(parsed);
+              yield parsed;
+            }
+          }
+          return;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const { events, remainder } = consumeSSEBuffer(buffer);
+        buffer = remainder;
+        for (const evt of events) {
+          const parsed = mapChatEvent(evt, this.requestId);
+          if (parsed) {
+            this.handleStreamEvent(parsed);
+            yield parsed;
+          }
+        }
+      }
+    } catch (err) {
+      this.recordFirstToken(err);
+      this.trace?.streamError?.({ context: this.context, error: err });
+      throw err;
+    } finally {
+      this.closed = true;
+      reader.releaseLock();
     }
-    src.addEventListener(
-      "abort",
-      () => controller.abort(src.reason),
-      { once: true }
-    );
   }
-  return controller.signal;
-}
-function normalizeHeaders(headers) {
-  if (!headers) return {};
-  const normalized = {};
-  for (const [key, value] of Object.entries(headers)) {
-    if (!key || !value) continue;
-    const k = key.trim();
-    const v = value.trim();
-    if (k && v) {
-      normalized[k] = v;
+  handleStreamEvent(evt) {
+    const context = this.enrichContext(evt);
+    this.context = context;
+    this.trace?.streamEvent?.({ context, event: evt });
+    if (evt.type === "message_start" || evt.type === "message_delta" || evt.type === "message_stop" || evt.type === "tool_use_start" || evt.type === "tool_use_delta" || evt.type === "tool_use_stop") {
+      this.recordFirstToken();
+    }
+    if (evt.type === "message_stop" && evt.usage && this.metrics?.usage) {
+      this.metrics.usage({ usage: evt.usage, context });
     }
   }
-  return normalized;
-}
-function buildRetryMetadata(attempt, lastStatus, lastError) {
-  if (!attempt || attempt <= 1) return void 0;
-  return {
-    attempts: attempt,
-    lastStatus,
-    lastError: typeof lastError === "string" ? lastError : lastError instanceof Error ? lastError.message : lastError ? String(lastError) : void 0
-  };
-}
-function classifyTransportErrorKind(err, connectTimedOut, requestTimedOut) {
-  if (connectTimedOut) return "connect";
-  if (requestTimedOut) return "timeout";
-  if (err instanceof DOMException && err.name === "AbortError") {
-    return requestTimedOut ? "timeout" : "request";
+  enrichContext(evt) {
+    return {
+      ...this.context,
+      responseId: evt.responseId || this.context.responseId,
+      requestId: evt.requestId || this.context.requestId,
+      model: evt.model || this.context.model
+    };
   }
-  if (err instanceof TypeError) return "request";
-  return "other";
-}
-function toTransportError(err, kind, retries) {
-  const message = err instanceof Error ? err.message : typeof err === "string" ? err : "request failed";
-  return new TransportError(message, { kind, retries, cause: err });
-}
-function recordHttpMetrics(metrics, trace, start, retries, info) {
-  if (!metrics?.httpRequest && !trace?.requestFinish) return;
-  const latencyMs = start ? Date.now() - start : 0;
-  if (metrics?.httpRequest) {
-    metrics.httpRequest({
+  recordFirstToken(error) {
+    if (!this.metrics?.streamFirstToken || this.firstTokenEmitted) return;
+    this.firstTokenEmitted = true;
+    const latencyMs = this.startedAt ? Date.now() - this.startedAt : 0;
+    this.metrics.streamFirstToken({
       latencyMs,
-      status: info.status,
-      error: info.error ? String(info.error) : void 0,
-      retries,
-      context: info.context
+      error: error ? String(error) : void 0,
+      context: this.context
     });
   }
-  trace?.requestFinish?.({
-    context: info.context,
-    status: info.status,
-    error: info.error,
-    retries,
-    latencyMs
-  });
-}
-function withRequestId(context, headers) {
-  const requestId = headers.get("X-ModelRelay-Chat-Request-Id") || headers.get("X-Request-Id") || context.requestId;
-  if (!requestId) return context;
-  return { ...context, requestId };
-}
-
-// src/tools.ts
-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 };
+};
+var StructuredJSONStream = class {
+  constructor(response, requestId, context, metrics, trace) {
+    this.closed = false;
+    this.sawTerminal = false;
+    if (!response.body) {
+      throw new ConfigError("streaming response is missing a body");
+    }
+    this.response = response;
+    this.requestId = requestId;
+    this.context = context;
+    this.metrics = metrics;
+    this.trace = trace;
   }
-  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;
+  async cancel(reason) {
+    this.closed = true;
+    try {
+      await this.response.body?.cancel(reason);
+    } catch {
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    if (this.closed) {
+      return;
+    }
+    const body = this.response.body;
+    if (!body) {
+      throw new ConfigError("streaming response is missing a body");
+    }
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        if (this.closed) {
+          await reader.cancel();
+          return;
+        }
+        const { value, done } = await reader.read();
+        if (done) {
+          const { records: records2 } = consumeNDJSONBuffer(buffer, true);
+          for (const line of records2) {
+            const evt = this.parseRecord(line);
+            if (evt) {
+              this.traceStructuredEvent(evt, line);
+              yield evt;
+            }
+          }
+          if (!this.sawTerminal) {
+            throw new TransportError(
+              "structured stream ended without completion or error",
+              { kind: "request" }
+            );
+          }
+          return;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const { records, remainder } = consumeNDJSONBuffer(buffer);
+        buffer = remainder;
+        for (const line of records) {
+          const evt = this.parseRecord(line);
+          if (evt) {
+            this.traceStructuredEvent(evt, line);
+            yield evt;
+          }
+        }
       }
-      return inner;
+    } catch (err) {
+      this.trace?.streamError?.({ context: this.context, error: err });
+      throw err;
+    } finally {
+      this.closed = true;
+      reader.releaseLock();
     }
-    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:
-      return {};
   }
-}
-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;
+  async collect() {
+    let last;
+    for await (const evt of this) {
+      last = evt;
+      if (evt.type === "completion") {
+        return evt.payload;
       }
     }
+    throw new TransportError(
+      "structured stream ended without completion or error",
+      { kind: "request" }
+    );
   }
-  if (def.description) {
-    result.description = def.description;
+  parseRecord(line) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (err) {
+      throw new TransportError("invalid JSON in structured stream", {
+        kind: "request",
+        cause: err
+      });
+    }
+    if (!parsed || typeof parsed !== "object") {
+      throw new TransportError("structured stream record is not an object", {
+        kind: "request"
+      });
+    }
+    const obj = parsed;
+    const rawType = String(obj.type || "").trim().toLowerCase();
+    if (!rawType) return null;
+    if (rawType === "start") {
+      return null;
+    }
+    if (rawType === "error") {
+      this.sawTerminal = true;
+      const status = typeof obj.status === "number" && obj.status > 0 ? obj.status : 500;
+      const message = typeof obj.message === "string" && obj.message.trim() ? obj.message : "structured stream error";
+      const code = typeof obj.code === "string" && obj.code.trim() ? obj.code : void 0;
+      throw new APIError(message, {
+        status,
+        code,
+        requestId: this.requestId
+      });
+    }
+    if (rawType !== "update" && rawType !== "completion") {
+      return null;
+    }
+    if (obj.payload === void 0 || obj.payload === null) {
+      throw new TransportError(
+        "structured stream record missing payload",
+        { kind: "request" }
+      );
+    }
+    if (rawType === "completion") {
+      this.sawTerminal = true;
+    }
+    const event = {
+      type: rawType,
+      // biome-ignore lint/suspicious/noExplicitAny: payload is untyped json
+      payload: obj.payload,
+      requestId: this.requestId
+    };
+    return event;
+  }
+  traceStructuredEvent(evt, raw) {
+    if (!this.trace?.streamEvent) return;
+    const event = {
+      type: "custom",
+      event: "structured",
+      data: { type: evt.type, payload: evt.payload },
+      textDelta: void 0,
+      toolCallDelta: void 0,
+      toolCalls: void 0,
+      responseId: void 0,
+      model: void 0,
+      stopReason: void 0,
+      usage: void 0,
+      requestId: this.requestId,
+      raw
+    };
+    this.trace.streamEvent({ context: this.context, event });
   }
-  return result;
+};
+function consumeSSEBuffer(buffer, flush = false) {
+  const events = [];
+  let eventName = "";
+  let dataLines = [];
+  let remainder = "";
+  const lines = buffer.split(/\r?\n/);
+  const lastIndex = lines.length - 1;
+  const limit = flush ? lines.length : Math.max(0, lastIndex);
+  const pushEvent = () => {
+    if (!eventName && dataLines.length === 0) {
+      return;
+    }
+    events.push({
+      event: eventName || "message",
+      data: dataLines.join("\n")
+    });
+    eventName = "";
+    dataLines = [];
+  };
+  for (let i = 0; i < limit; i++) {
+    const line = lines[i];
+    if (line === "") {
+      pushEvent();
+      continue;
+    }
+    if (line.startsWith(":")) {
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      eventName = line.slice(6).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).trimStart());
+    }
+  }
+  if (flush) {
+    pushEvent();
+    remainder = "";
+  } else {
+    remainder = lines[lastIndex] ?? "";
+  }
+  return { events, remainder };
 }
-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;
-      }
+function consumeNDJSONBuffer(buffer, flush = false) {
+  const lines = buffer.split(/\r?\n/);
+  const records = [];
+  const lastIndex = lines.length - 1;
+  const limit = flush ? lines.length : Math.max(0, lastIndex);
+  for (let i = 0; i < limit; i++) {
+    const line = lines[i]?.trim();
+    if (!line) continue;
+    records.push(line);
+  }
+  const remainder = flush ? "" : lines[lastIndex] ?? "";
+  return { records, remainder };
+}
+function mapChatEvent(raw, requestId) {
+  let parsed = raw.data;
+  if (raw.data) {
+    try {
+      parsed = JSON.parse(raw.data);
+    } catch {
+      parsed = raw.data;
     }
   }
-  if (def.description) {
-    result.description = def.description;
+  const payload = typeof parsed === "object" && parsed !== null ? parsed : {};
+  const p = payload;
+  const type = normalizeEventType(raw.event, p);
+  const usage = normalizeUsage(p.usage);
+  const responseId = p.response_id || p.id || p?.message?.id;
+  const model = normalizeModelId(p.model || p?.message?.model);
+  const stopReason = normalizeStopReason(p.stop_reason);
+  const textDelta = extractTextDelta(p);
+  const toolCallDelta = extractToolCallDelta(p, type);
+  const toolCalls = extractToolCalls(p, type);
+  return {
+    type,
+    event: raw.event || type,
+    data: p,
+    textDelta,
+    toolCallDelta,
+    toolCalls,
+    responseId,
+    model,
+    stopReason,
+    usage,
+    requestId,
+    raw: raw.data || ""
+  };
+}
+function normalizeEventType(eventName, payload) {
+  const hint = String(
+    payload?.type || payload?.event || eventName || ""
+  ).trim();
+  switch (hint) {
+    case "message_start":
+      return "message_start";
+    case "message_delta":
+      return "message_delta";
+    case "message_stop":
+      return "message_stop";
+    case "tool_use_start":
+      return "tool_use_start";
+    case "tool_use_delta":
+      return "tool_use_delta";
+    case "tool_use_stop":
+      return "tool_use_stop";
+    case "ping":
+      return "ping";
+    default:
+      return "custom";
   }
-  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;
+function extractTextDelta(payload) {
+  if (!payload || typeof payload !== "object") {
+    return void 0;
   }
-  if (def.maxLength !== void 0 && def.maxLength !== null) {
-    result.maxItems = def.maxLength.value;
+  if (typeof payload.text_delta === "string" && payload.text_delta !== "") {
+    return payload.text_delta;
   }
-  if (def.description) {
-    result.description = def.description;
+  if (typeof payload.delta === "string") {
+    return payload.delta;
   }
-  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);
+  if (payload.delta && typeof payload.delta === "object") {
+    if (typeof payload.delta.text === "string") {
+      return payload.delta.text;
+    }
+    if (typeof payload.delta.content === "string") {
+      return payload.delta.content;
     }
   }
-  const result = {
-    type: "object",
-    properties
-  };
-  if (required.length > 0) {
-    result.required = required;
+  return void 0;
+}
+function extractToolCallDelta(payload, type) {
+  if (!payload || typeof payload !== "object") {
+    return void 0;
   }
-  if (def.description) {
-    result.description = def.description;
+  if (type !== "tool_use_start" && type !== "tool_use_delta") {
+    return void 0;
   }
-  const unknownKeys = def.unknownKeys;
-  if (unknownKeys === "strict") {
-    result.additionalProperties = false;
+  if (payload.tool_call_delta) {
+    const d = payload.tool_call_delta;
+    return {
+      index: d.index ?? 0,
+      id: d.id,
+      type: d.type,
+      function: d.function ? {
+        name: d.function.name,
+        arguments: d.function.arguments
+      } : void 0
+    };
   }
-  return result;
-}
-function convertZodEnum(def) {
-  const result = {
-    type: "string",
-    enum: def.values
-  };
-  if (def.description) {
-    result.description = def.description;
+  if (typeof payload.index === "number" || payload.id || payload.name) {
+    return {
+      index: payload.index ?? 0,
+      id: payload.id,
+      type: payload.tool_type,
+      function: payload.name || payload.arguments ? {
+        name: payload.name,
+        arguments: payload.arguments
+      } : void 0
+    };
   }
-  return result;
+  return void 0;
 }
-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;
+function extractToolCalls(payload, type) {
+  if (!payload || typeof payload !== "object") {
+    return void 0;
   }
-  return result;
-}
-function convertZodUnion(def) {
-  const options = def.options;
-  const result = {
-    anyOf: options.map(convertZodType)
-  };
-  if (def.description) {
-    result.description = def.description;
+  if (type !== "tool_use_stop" && type !== "message_stop") {
+    return void 0;
   }
-  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;
+  if (payload.tool_calls?.length) {
+    return normalizeToolCalls(payload.tool_calls);
   }
-  return result;
+  if (payload.tool_call) {
+    return normalizeToolCalls([payload.tool_call]);
+  }
+  return void 0;
 }
-function convertZodTuple(def) {
-  const items = def.items;
-  const result = {
-    type: "array",
-    items: items.map(convertZodType),
-    minItems: items.length,
-    maxItems: items.length
+function normalizeChatResponse(payload, requestId) {
+  const p = payload;
+  const response = {
+    id: p?.id,
+    content: Array.isArray(p?.content) ? p.content : p?.content ? [String(p.content)] : [],
+    stopReason: normalizeStopReason(p?.stop_reason),
+    model: normalizeModelId(p?.model),
+    usage: normalizeUsage(p?.usage),
+    requestId
   };
-  if (def.description) {
-    result.description = def.description;
+  if (p?.tool_calls?.length) {
+    response.toolCalls = normalizeToolCalls(p.tool_calls);
   }
-  return result;
+  return response;
 }
-function createFunctionToolFromSchema(name, description, schema, options) {
-  const jsonSchema = zodToJsonSchema(schema, options);
-  return createFunctionTool(name, description, jsonSchema);
+function normalizeToolCalls(toolCalls) {
+  return toolCalls.map(
+    (tc) => createToolCall(
+      tc.id,
+      tc.function?.name ?? "",
+      tc.function?.arguments ?? "",
+      tc.type || ToolTypes.Function
+    )
+  );
 }
-function createFunctionTool(name, description, parameters) {
-  const fn = { name, description };
-  if (parameters) {
-    fn.parameters = parameters;
+function normalizeUsage(payload) {
+  if (!payload) {
+    return createUsage(0, 0, 0);
   }
-  return {
-    type: ToolTypes.Function,
-    function: fn
-  };
+  const inputTokens = Number(payload.input_tokens ?? 0);
+  const outputTokens = Number(payload.output_tokens ?? 0);
+  const totalTokens = Number(payload.total_tokens ?? 0);
+  return createUsage(inputTokens, outputTokens, totalTokens || void 0);
 }
-function createWebSearchTool(options) {
-  return {
-    type: ToolTypes.WebSearch,
-    webSearch: options ? {
-      allowedDomains: options.allowedDomains,
-      excludedDomains: options.excludedDomains,
-      maxUses: options.maxUses
-    } : void 0
+function buildProxyBody(params, metadata) {
+  const modelValue = params.model ? modelToString(params.model).trim() : "";
+  const body = {
+    messages: normalizeMessages(params.messages)
   };
+  if (modelValue) {
+    body.model = modelValue;
+  }
+  if (typeof params.maxTokens === "number") body.max_tokens = params.maxTokens;
+  if (typeof params.temperature === "number")
+    body.temperature = params.temperature;
+  if (metadata && Object.keys(metadata).length > 0) body.metadata = metadata;
+  if (params.stop?.length) body.stop = params.stop;
+  if (params.stopSequences?.length) body.stop_sequences = params.stopSequences;
+  if (params.tools?.length) body.tools = normalizeTools(params.tools);
+  if (params.toolChoice) body.tool_choice = normalizeToolChoice(params.toolChoice);
+  if (params.responseFormat) body.response_format = params.responseFormat;
+  return body;
 }
-function toolChoiceAuto() {
-  return { type: ToolChoiceTypes.Auto };
-}
-function toolChoiceRequired() {
-  return { type: ToolChoiceTypes.Required };
+function normalizeMessages(messages) {
+  return messages.map((msg) => {
+    const normalized = {
+      role: msg.role || "user",
+      content: msg.content
+    };
+    if (msg.toolCalls?.length) {
+      normalized.tool_calls = msg.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: tc.type,
+        function: tc.function ? createFunctionCall(tc.function.name, tc.function.arguments) : void 0
+      }));
+    }
+    if (msg.toolCallId) {
+      normalized.tool_call_id = msg.toolCallId;
+    }
+    return normalized;
+  });
 }
-function toolChoiceNone() {
-  return { type: ToolChoiceTypes.None };
+function normalizeTools(tools) {
+  return tools.map((tool) => {
+    const normalized = { type: tool.type };
+    if (tool.function) {
+      normalized.function = {
+        name: tool.function.name,
+        description: tool.function.description,
+        parameters: tool.function.parameters
+      };
+    }
+    if (tool.web) {
+      const web = {
+        allowed_domains: tool.web.allowedDomains,
+        excluded_domains: tool.web.excludedDomains,
+        max_uses: tool.web.maxUses
+      };
+      if (tool.web.mode) {
+        web.mode = tool.web.mode;
+      }
+      normalized.web = web;
+    }
+    if (tool.xSearch) {
+      normalized.x_search = {
+        allowed_handles: tool.xSearch.allowedHandles,
+        excluded_handles: tool.xSearch.excludedHandles,
+        from_date: tool.xSearch.fromDate,
+        to_date: tool.xSearch.toDate
+      };
+    }
+    if (tool.codeExecution) {
+      normalized.code_execution = {
+        language: tool.codeExecution.language,
+        timeout_ms: tool.codeExecution.timeoutMs
+      };
+    }
+    return normalized;
+  });
 }
-function hasToolCalls(response) {
-  return (response.toolCalls?.length ?? 0) > 0;
+function normalizeToolChoice(tc) {
+  return { type: tc.type };
 }
-function firstToolCall(response) {
-  return response.toolCalls?.[0];
+function requestIdFromHeaders(headers) {
+  return headers.get(REQUEST_ID_HEADER) || headers.get("X-Request-Id") || void 0;
 }
-function toolResultMessage(toolCallId, result) {
-  const content = typeof result === "string" ? result : JSON.stringify(result);
-  return {
-    role: "tool",
-    content,
-    toolCallId
-  };
+function mergeMetadata(...sources) {
+  const merged = {};
+  for (const src of sources) {
+    if (!src) continue;
+    for (const [key, value] of Object.entries(src)) {
+      const k = key?.trim();
+      const v = value?.trim();
+      if (!k || !v) continue;
+      merged[k] = v;
+    }
+  }
+  return Object.keys(merged).length ? merged : void 0;
 }
-function respondToToolCall(call, result) {
-  return toolResultMessage(call.id, result);
+function hasUserMessage(messages) {
+  return messages.some(
+    (msg) => msg.role?.toLowerCase?.() === "user" && !!msg.content
+  );
 }
-function assistantMessageWithToolCalls(content, toolCalls) {
-  return {
-    role: "assistant",
-    content,
-    toolCalls
-  };
+
+// src/customers.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function isValidEmail(email) {
+  return EMAIL_REGEX.test(email);
 }
-var ToolCallAccumulator = class {
-  constructor() {
-    this.calls = /* @__PURE__ */ new Map();
+var CustomersClient = class {
+  constructor(http, cfg) {
+    this.http = http;
+    this.apiKey = cfg.apiKey;
+  }
+  ensureSecretKey() {
+    if (!this.apiKey || !this.apiKey.startsWith("mr_sk_")) {
+      throw new ConfigError(
+        "Secret key (mr_sk_*) required for customer operations"
+      );
+    }
   }
   /**
-   * Processes a streaming tool call delta.
-   * Returns true if this started a new tool call.
+   * List all customers in the project.
    */
-  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;
+  async list() {
+    this.ensureSecretKey();
+    const response = await this.http.json("/customers", {
+      method: "GET",
+      apiKey: this.apiKey
+    });
+    return response.customers;
+  }
+  /**
+   * Create a new customer in the project.
+   */
+  async create(request) {
+    this.ensureSecretKey();
+    if (!request.tier_id?.trim()) {
+      throw new ConfigError("tier_id is required");
     }
-    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;
-      }
+    if (!request.external_id?.trim()) {
+      throw new ConfigError("external_id is required");
     }
-    return false;
+    if (!request.email?.trim()) {
+      throw new ConfigError("email is required");
+    }
+    if (!isValidEmail(request.email)) {
+      throw new ConfigError("invalid email format");
+    }
+    const response = await this.http.json("/customers", {
+      method: "POST",
+      body: request,
+      apiKey: this.apiKey
+    });
+    return response.customer;
   }
   /**
-   * Returns all accumulated tool calls in index order.
+   * Get a customer by ID.
    */
-  getToolCalls() {
-    if (this.calls.size === 0) {
-      return [];
+  async get(customerId) {
+    this.ensureSecretKey();
+    if (!customerId?.trim()) {
+      throw new ConfigError("customerId is required");
     }
-    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);
+    const response = await this.http.json(
+      `/customers/${customerId}`,
+      {
+        method: "GET",
+        apiKey: this.apiKey
       }
-    }
-    return result;
+    );
+    return response.customer;
   }
   /**
-   * Returns a specific tool call by index, or undefined if not found.
+   * Upsert a customer by external_id.
+   * If a customer with the given external_id exists, it is updated.
+   * Otherwise, a new customer is created.
    */
-  getToolCall(index) {
-    return this.calls.get(index);
+  async upsert(request) {
+    this.ensureSecretKey();
+    if (!request.tier_id?.trim()) {
+      throw new ConfigError("tier_id is required");
+    }
+    if (!request.external_id?.trim()) {
+      throw new ConfigError("external_id is required");
+    }
+    if (!request.email?.trim()) {
+      throw new ConfigError("email is required");
+    }
+    if (!isValidEmail(request.email)) {
+      throw new ConfigError("invalid email format");
+    }
+    const response = await this.http.json("/customers", {
+      method: "PUT",
+      body: request,
+      apiKey: this.apiKey
+    });
+    return response.customer;
   }
   /**
-   * Clears all accumulated tool calls.
+   * Claim a customer by email, setting their external_id.
+   * Used when a customer subscribes via Stripe Checkout (email only) and later
+   * authenticates to the app, needing to link their identity.
+   *
+   * @throws {APIError} with status 404 if customer not found by email
+   * @throws {APIError} with status 409 if customer already claimed or external_id in use
    */
-  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 parseToolArgs(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);
+  async claim(request) {
+    this.ensureSecretKey();
+    if (!request.email?.trim()) {
+      throw new ConfigError("email is required");
     }
-    throw new ToolArgsError(
-      `Invalid arguments for tool '${toolName}': ${message}`,
-      call.id,
-      toolName,
-      rawArgs
-    );
-  }
-}
-function tryParseToolArgs(call, schema) {
-  try {
-    const data = parseToolArgs(call, schema);
-    return { success: true, data };
-  } catch (err) {
-    if (err instanceof ToolArgsError) {
-      return { success: false, error: err };
+    if (!isValidEmail(request.email)) {
+      throw new ConfigError("invalid email format");
     }
-    const toolName = call.function?.name ?? "unknown";
-    const rawArgs = call.function?.arguments ?? "";
-    return {
-      success: false,
-      error: new ToolArgsError(
-        err instanceof Error ? err.message : String(err),
-        call.id,
-        toolName,
-        rawArgs
-      )
-    };
-  }
-}
-function parseToolArgsRaw(call) {
-  const toolName = call.function?.name ?? "unknown";
-  const rawArgs = call.function?.arguments ?? "";
-  try {
-    return 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
-    );
+    if (!request.external_id?.trim()) {
+      throw new ConfigError("external_id is required");
+    }
+    const response = await this.http.json("/customers/claim", {
+      method: "POST",
+      body: request,
+      apiKey: this.apiKey
+    });
+    return response.customer;
   }
-}
-var ToolRegistry = class {
-  constructor() {
-    this.handlers = /* @__PURE__ */ new Map();
+  /**
+   * Delete a customer by ID.
+   */
+  async delete(customerId) {
+    this.ensureSecretKey();
+    if (!customerId?.trim()) {
+      throw new ConfigError("customerId is required");
+    }
+    await this.http.request(`/customers/${customerId}`, {
+      method: "DELETE",
+      apiKey: this.apiKey
+    });
   }
   /**
-   * 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
+   * Create a Stripe checkout session for a customer.
    */
-  register(name, handler) {
-    this.handlers.set(name, handler);
-    return this;
+  async createCheckoutSession(customerId, request) {
+    this.ensureSecretKey();
+    if (!customerId?.trim()) {
+      throw new ConfigError("customerId is required");
+    }
+    if (!request.success_url?.trim() || !request.cancel_url?.trim()) {
+      throw new ConfigError("success_url and cancel_url are required");
+    }
+    return await this.http.json(
+      `/customers/${customerId}/checkout`,
+      {
+        method: "POST",
+        body: request,
+        apiKey: this.apiKey
+      }
+    );
   }
   /**
-   * Unregisters a tool handler.
-   * @param name - The tool name to unregister
-   * @returns true if the handler was removed, false if it didn't exist
+   * Get the subscription status for a customer.
    */
-  unregister(name) {
-    return this.handlers.delete(name);
+  async getSubscription(customerId) {
+    this.ensureSecretKey();
+    if (!customerId?.trim()) {
+      throw new ConfigError("customerId is required");
+    }
+    return await this.http.json(
+      `/customers/${customerId}/subscription`,
+      {
+        method: "GET",
+        apiKey: this.apiKey
+      }
+    );
+  }
+};
+
+// src/tiers.ts
+var TiersClient = class {
+  constructor(http, cfg) {
+    this.http = http;
+    this.apiKey = cfg.apiKey;
+  }
+  ensureApiKey() {
+    if (!this.apiKey || !this.apiKey.startsWith("mr_pk_") && !this.apiKey.startsWith("mr_sk_")) {
+      throw new ConfigError(
+        "API key (mr_pk_* or mr_sk_*) required for tier operations"
+      );
+    }
   }
   /**
-   * Checks if a handler is registered for the given tool name.
+   * List all tiers in the project.
    */
-  has(name) {
-    return this.handlers.has(name);
+  async list() {
+    this.ensureApiKey();
+    const response = await this.http.json("/tiers", {
+      method: "GET",
+      apiKey: this.apiKey
+    });
+    return response.tiers;
   }
   /**
-   * Returns the list of registered tool names.
+   * Get a tier by ID.
    */
-  getRegisteredTools() {
-    return Array.from(this.handlers.keys());
+  async get(tierId) {
+    this.ensureApiKey();
+    if (!tierId?.trim()) {
+      throw new ConfigError("tierId is required");
+    }
+    const response = await this.http.json(`/tiers/${tierId}`, {
+      method: "GET",
+      apiKey: this.apiKey
+    });
+    return response.tier;
+  }
+};
+
+// src/http.ts
+var HTTPClient = class {
+  constructor(cfg) {
+    const resolvedBase = normalizeBaseUrl(cfg.baseUrl || DEFAULT_BASE_URL);
+    if (!isValidHttpUrl(resolvedBase)) {
+      throw new ConfigError(
+        "baseUrl must start with http:// or https://"
+      );
+    }
+    this.baseUrl = resolvedBase;
+    this.apiKey = cfg.apiKey?.trim();
+    this.accessToken = cfg.accessToken?.trim();
+    this.fetchImpl = cfg.fetchImpl;
+    this.clientHeader = cfg.clientHeader?.trim() || DEFAULT_CLIENT_HEADER;
+    this.defaultConnectTimeoutMs = cfg.connectTimeoutMs === void 0 ? DEFAULT_CONNECT_TIMEOUT_MS : Math.max(0, cfg.connectTimeoutMs);
+    this.defaultTimeoutMs = cfg.timeoutMs === void 0 ? DEFAULT_REQUEST_TIMEOUT_MS : Math.max(0, cfg.timeoutMs);
+    this.retry = normalizeRetryConfig(cfg.retry);
+    this.defaultHeaders = normalizeHeaders(cfg.defaultHeaders);
+    this.metrics = cfg.metrics;
+    this.trace = cfg.trace;
+  }
+  async request(path, options = {}) {
+    const fetchFn = this.fetchImpl ?? globalThis.fetch;
+    if (!fetchFn) {
+      throw new ConfigError(
+        "fetch is not available; provide a fetch implementation"
+      );
+    }
+    const method = options.method || "GET";
+    const url = buildUrl(this.baseUrl, path);
+    const metrics = mergeMetrics(this.metrics, options.metrics);
+    const trace = mergeTrace(this.trace, options.trace);
+    const context = {
+      method,
+      path,
+      ...options.context || {}
+    };
+    trace?.requestStart?.(context);
+    const start = metrics?.httpRequest || trace?.requestFinish ? Date.now() : 0;
+    const headers = new Headers({
+      ...this.defaultHeaders,
+      ...options.headers || {}
+    });
+    const accepts = options.accept || (options.raw ? void 0 : "application/json");
+    if (accepts && !headers.has("Accept")) {
+      headers.set("Accept", accepts);
+    }
+    const body = options.body;
+    const shouldEncodeJSON = body !== void 0 && body !== null && typeof body === "object" && !(body instanceof FormData) && !(body instanceof Blob);
+    const payload = shouldEncodeJSON ? JSON.stringify(body) : body;
+    if (shouldEncodeJSON && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    const accessToken = options.accessToken ?? this.accessToken;
+    if (accessToken) {
+      const bearer = accessToken.toLowerCase().startsWith("bearer ") ? accessToken : `Bearer ${accessToken}`;
+      headers.set("Authorization", bearer);
+    }
+    const apiKey = options.apiKey ?? this.apiKey;
+    if (apiKey) {
+      headers.set("X-ModelRelay-Api-Key", apiKey);
+    }
+    if (this.clientHeader && !headers.has("X-ModelRelay-Client")) {
+      headers.set("X-ModelRelay-Client", this.clientHeader);
+    }
+    const timeoutMs = options.useDefaultTimeout === false ? options.timeoutMs : options.timeoutMs ?? this.defaultTimeoutMs;
+    const connectTimeoutMs = options.useDefaultConnectTimeout === false ? options.connectTimeoutMs : options.connectTimeoutMs ?? this.defaultConnectTimeoutMs;
+    const retryCfg = normalizeRetryConfig(
+      options.retry === void 0 ? this.retry : options.retry
+    );
+    const attempts = retryCfg ? Math.max(1, retryCfg.maxAttempts) : 1;
+    let lastError;
+    let lastStatus;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      let connectTimedOut = false;
+      let requestTimedOut = false;
+      const connectController = connectTimeoutMs && connectTimeoutMs > 0 ? new AbortController() : void 0;
+      const requestController = timeoutMs && timeoutMs > 0 ? new AbortController() : void 0;
+      const signal = mergeSignals(
+        options.signal,
+        connectController?.signal,
+        requestController?.signal
+      );
+      const connectTimer = connectController && setTimeout(() => {
+        connectTimedOut = true;
+        connectController.abort(
+          new DOMException("connect timeout", "AbortError")
+        );
+      }, connectTimeoutMs);
+      const requestTimer = requestController && setTimeout(() => {
+        requestTimedOut = true;
+        requestController.abort(
+          new DOMException("timeout", "AbortError")
+        );
+      }, timeoutMs);
+      try {
+        const response = await fetchFn(url, {
+          method,
+          headers,
+          body: payload,
+          signal
+        });
+        if (connectTimer) {
+          clearTimeout(connectTimer);
+        }
+        if (!response.ok) {
+          const shouldRetry = retryCfg && shouldRetryStatus(
+            response.status,
+            method,
+            retryCfg.retryPost
+          ) && attempt < attempts;
+          if (shouldRetry) {
+            lastStatus = response.status;
+            await backoff(attempt, retryCfg);
+            continue;
+          }
+          const retries = buildRetryMetadata(attempt, response.status, lastError);
+          const finishedCtx2 = withRequestId(context, response.headers);
+          recordHttpMetrics(metrics, trace, start, retries, {
+            status: response.status,
+            context: finishedCtx2
+          });
+          throw options.raw ? await parseErrorResponse(response, retries) : await parseErrorResponse(response, retries);
+        }
+        const finishedCtx = withRequestId(context, response.headers);
+        recordHttpMetrics(metrics, trace, start, void 0, {
+          status: response.status,
+          context: finishedCtx
+        });
+        return response;
+      } catch (err) {
+        if (options.signal?.aborted) {
+          throw err;
+        }
+        if (err instanceof ModelRelayError) {
+          recordHttpMetrics(metrics, trace, start, void 0, {
+            error: err,
+            context
+          });
+          throw err;
+        }
+        const transportKind = classifyTransportErrorKind(
+          err,
+          connectTimedOut,
+          requestTimedOut
+        );
+        const shouldRetry = retryCfg && isRetryableError(err, transportKind) && (method !== "POST" || retryCfg.retryPost) && attempt < attempts;
+        if (!shouldRetry) {
+          const retries = buildRetryMetadata(
+            attempt,
+            lastStatus,
+            err instanceof Error ? err.message : String(err)
+          );
+          recordHttpMetrics(metrics, trace, start, retries, {
+            error: err,
+            context
+          });
+          throw toTransportError(err, transportKind, retries);
+        }
+        lastError = err;
+        await backoff(attempt, retryCfg);
+      } finally {
+        if (connectTimer) {
+          clearTimeout(connectTimer);
+        }
+        if (requestTimer) {
+          clearTimeout(requestTimer);
+        }
+      }
+    }
+    throw lastError instanceof Error ? lastError : new TransportError("request failed", {
+      kind: "other",
+      retries: buildRetryMetadata(attempts, lastStatus)
+    });
   }
-  /**
-   * 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"}`
-      };
+  async json(path, options = {}) {
+    const response = await this.request(path, {
+      ...options,
+      raw: true,
+      accept: options.accept || "application/json"
+    });
+    if (!response.ok) {
+      throw await parseErrorResponse(response);
     }
-    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
-      };
+    if (response.status === 204) {
+      return void 0;
     }
     try {
-      const result = await handler(args, call);
-      return {
-        toolCallId: call.id,
-        toolName,
-        result
-      };
+      return await response.json();
     } catch (err) {
-      const isRetryable = err instanceof ToolArgsError;
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      return {
-        toolCallId: call.id,
-        toolName,
-        result: null,
-        error: errorMessage,
-        isRetryable
-      };
+      throw new APIError("failed to parse response JSON", {
+        status: response.status,
+        data: err
+      });
     }
   }
-  /**
-   * 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)));
+};
+function buildUrl(baseUrl, path) {
+  if (/^https?:\/\//i.test(path)) {
+    return path;
   }
-  /**
-   * Converts execution results to tool result messages.
-   * Useful for appending to the conversation history.
-   * @param results - Array of execution results
-   * @returns Array of ChatMessage objects with 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);
-    });
+  if (!path.startsWith("/")) {
+    path = `/${path}`;
   }
-};
-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 `${baseUrl}${path}`;
+}
+function normalizeBaseUrl(value) {
+  const trimmed = value.trim();
+  if (trimmed.endsWith("/")) {
+    return trimmed.slice(0, -1);
   }
-  return lines.join("\n");
+  return trimmed;
 }
-function hasRetryableErrors(results) {
-  return results.some((r) => r.error && r.isRetryable);
+function isValidHttpUrl(value) {
+  return /^https?:\/\//i.test(value);
 }
-function getRetryableErrors(results) {
-  return results.filter((r) => r.error && r.isRetryable);
+function normalizeRetryConfig(retry) {
+  if (retry === false) return void 0;
+  const cfg = retry || {};
+  return {
+    maxAttempts: Math.max(1, cfg.maxAttempts ?? 3),
+    baseBackoffMs: Math.max(0, cfg.baseBackoffMs ?? 300),
+    maxBackoffMs: Math.max(0, cfg.maxBackoffMs ?? 5e3),
+    retryPost: cfg.retryPost ?? true
+  };
 }
-function createRetryMessages(results) {
-  return results.filter((r) => r.error && r.isRetryable).map((r) => toolResultMessage(r.toolCallId, formatToolErrorForModel(r)));
+function shouldRetryStatus(status, method, retryPost) {
+  if (status === 408 || status === 429) {
+    return method !== "POST" || retryPost;
+  }
+  if (status >= 500 && status < 600) {
+    return method !== "POST" || retryPost;
+  }
+  return false;
 }
-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());
+function isRetryableError(err, kind) {
+  if (!err) return false;
+  if (kind === "timeout" || kind === "connect") return true;
+  return err instanceof DOMException || err instanceof TypeError;
+}
+function backoff(attempt, cfg) {
+  const exp = Math.max(0, attempt - 1);
+  const base = cfg.baseBackoffMs * Math.pow(2, Math.min(exp, 10));
+  const capped = Math.min(base, cfg.maxBackoffMs);
+  const jitter = 0.5 + Math.random();
+  const delay = Math.min(cfg.maxBackoffMs, capped * jitter);
+  if (delay <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, delay));
+}
+function mergeSignals(...signals) {
+  const active = signals.filter(Boolean);
+  if (active.length === 0) return void 0;
+  if (active.length === 1) return active[0];
+  const controller = new AbortController();
+  for (const src of active) {
+    if (src.aborted) {
+      controller.abort(src.reason);
+      break;
     }
-    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());
+    src.addEventListener(
+      "abort",
+      () => controller.abort(src.reason),
+      { once: true }
+    );
+  }
+  return controller.signal;
+}
+function normalizeHeaders(headers) {
+  if (!headers) return {};
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (!key || !value) continue;
+    const k = key.trim();
+    const v = value.trim();
+    if (k && v) {
+      normalized[k] = v;
     }
-    currentCalls = newCalls;
   }
-  return Array.from(successfulResults.values());
+  return normalized;
+}
+function buildRetryMetadata(attempt, lastStatus, lastError) {
+  if (!attempt || attempt <= 1) return void 0;
+  return {
+    attempts: attempt,
+    lastStatus,
+    lastError: typeof lastError === "string" ? lastError : lastError instanceof Error ? lastError.message : lastError ? String(lastError) : void 0
+  };
+}
+function classifyTransportErrorKind(err, connectTimedOut, requestTimedOut) {
+  if (connectTimedOut) return "connect";
+  if (requestTimedOut) return "timeout";
+  if (err instanceof DOMException && err.name === "AbortError") {
+    return requestTimedOut ? "timeout" : "request";
+  }
+  if (err instanceof TypeError) return "request";
+  return "other";
+}
+function toTransportError(err, kind, retries) {
+  const message = err instanceof Error ? err.message : typeof err === "string" ? err : "request failed";
+  return new TransportError(message, { kind, retries, cause: err });
+}
+function recordHttpMetrics(metrics, trace, start, retries, info) {
+  if (!metrics?.httpRequest && !trace?.requestFinish) return;
+  const latencyMs = start ? Date.now() - start : 0;
+  if (metrics?.httpRequest) {
+    metrics.httpRequest({
+      latencyMs,
+      status: info.status,
+      error: info.error ? String(info.error) : void 0,
+      retries,
+      context: info.context
+    });
+  }
+  trace?.requestFinish?.({
+    context: info.context,
+    status: info.status,
+    error: info.error,
+    retries,
+    latencyMs
+  });
+}
+function withRequestId(context, headers) {
+  const requestId = headers.get("X-ModelRelay-Chat-Request-Id") || headers.get("X-Request-Id") || context.requestId;
+  if (!requestId) return context;
+  return { ...context, requestId };
 }
 
 // src/index.ts
@@ -2022,12 +2349,13 @@ export {
   DEFAULT_CLIENT_HEADER,
   DEFAULT_CONNECT_TIMEOUT_MS,
   DEFAULT_REQUEST_TIMEOUT_MS,
+  ErrorCodes,
   ModelRelay,
   ModelRelayError,
-  Models,
-  Providers,
+  ResponseFormatTypes,
   SDK_VERSION,
   StopReasons,
+  StructuredJSONStream,
   TiersClient,
   ToolArgsError,
   ToolCallAccumulator,
@@ -2035,11 +2363,20 @@ export {
   ToolRegistry,
   ToolTypes,
   TransportError,
+  WebToolModes,
   assistantMessageWithToolCalls,
+  createAccessTokenAuth,
+  createApiKeyAuth,
+  createAssistantMessage,
+  createFunctionCall,
   createFunctionTool,
   createFunctionToolFromSchema,
   createRetryMessages,
-  createWebSearchTool,
+  createSystemMessage,
+  createToolCall,
+  createUsage,
+  createUserMessage,
+  createWebTool,
   executeWithRetry,
   firstToolCall,
   formatToolErrorForModel,
@@ -2051,12 +2388,10 @@ export {
   mergeTrace,
   modelToString,
   normalizeModelId,
-  normalizeProvider,
   normalizeStopReason,
   parseErrorResponse,
   parseToolArgs,
   parseToolArgsRaw,
-  providerToString,
   respondToToolCall,
   stopReasonToString,
   toolChoiceAuto,