@modelrelay/sdk 1.3.2 → 1.10.3

package/dist/index.js

@@ -159,6 +159,28 @@ var WorkflowValidationError = class extends ModelRelayError {
     this.issues = opts.issues;
   }
 };
+var ToolArgumentError = class extends ModelRelayError {
+  constructor(opts) {
+    super(opts.message, {
+      category: "config",
+      status: 400,
+      cause: opts.cause
+    });
+    this.toolCallId = opts.toolCallId;
+    this.toolName = opts.toolName;
+    this.rawArguments = opts.rawArguments;
+  }
+};
+var PathEscapeError = class extends ModelRelayError {
+  constructor(opts) {
+    super(`path escapes sandbox: ${opts.requestedPath}`, {
+      category: "config",
+      status: 403
+    });
+    this.requestedPath = opts.requestedPath;
+    this.resolvedPath = opts.resolvedPath;
+  }
+};
 function isEmailRequired(err) {
   return err instanceof APIError && err.isEmailRequired();
 }
@@ -205,10 +227,10 @@ async function parseErrorResponse(response, retries) {
         if (!raw || typeof raw !== "object") continue;
         const obj = raw;
         const code = typeof obj.code === "string" ? obj.code : "";
-        const path = typeof obj.path === "string" ? obj.path : "";
+        const path2 = typeof obj.path === "string" ? obj.path : "";
         const message = typeof obj.message === "string" ? obj.message : "";
-        if (!code || !path || !message) continue;
-        normalized.push({ code, path, message });
+        if (!code || !path2 || !message) continue;
+        normalized.push({ code, path: path2, message });
       }
       if (normalized.length > 0) {
         return new WorkflowValidationError({
@@ -449,24 +471,18 @@ var AuthClient = class {
    * Mint a customer-scoped bearer token (requires a secret key).
    */
   async customerToken(request) {
-    const projectId = request.projectId?.trim();
-    if (!projectId) {
-      throw new ConfigError("projectId is required");
-    }
     const customerId = request.customerId?.trim();
     const customerExternalId = request.customerExternalId?.trim();
     if (!!customerId && !!customerExternalId || !customerId && !customerExternalId) {
       throw new ConfigError("Provide exactly one of customerId or customerExternalId");
     }
-    if (request.ttlSeconds !== void 0 && request.ttlSeconds <= 0) {
-      throw new ConfigError("ttlSeconds must be positive when provided");
+    if (request.ttlSeconds !== void 0 && request.ttlSeconds < 0) {
+      throw new ConfigError("ttlSeconds must be non-negative when provided");
     }
     if (!this.apiKey || this.apiKeyIsPublishable) {
       throw new ConfigError("Secret API key is required to mint customer tokens");
     }
-    const payload = {
-      project_id: projectId
-    };
+    const payload = {};
     if (customerId) {
       payload.customer_id = customerId;
     }
@@ -564,8 +580,8 @@ var AuthClient = class {
       params.set("provider", request.provider);
     }
     const queryString = params.toString();
-    const path = queryString ? `/auth/device/start?${queryString}` : "/auth/device/start";
-    const apiResp = await this.http.json(path, {
+    const path2 = queryString ? `/auth/device/start?${queryString}` : "/auth/device/start";
+    const apiResp = await this.http.json(path2, {
       method: "POST",
       apiKey: this.apiKey
     });
@@ -629,7 +645,7 @@ var AuthClient = class {
           token: apiResp.token,
           expiresAt: new Date(apiResp.expires_at),
           expiresIn: apiResp.expires_in,
-          tokenType: apiResp.token_type,
+          tokenType: "Bearer",
           projectId: apiResp.project_id,
           customerId: apiResp.customer_id,
           customerExternalId: apiResp.customer_external_id,
@@ -688,7 +704,7 @@ function isTokenReusable(token) {
 // package.json
 var package_default = {
   name: "@modelrelay/sdk",
-  version: "1.3.2",
+  version: "1.10.3",
   description: "TypeScript SDK for the ModelRelay API",
   type: "module",
   main: "dist/index.cjs",
@@ -701,12 +717,14 @@ var package_default = {
       require: "./dist/index.cjs"
     }
   },
-  publishConfig: { access: "public" },
+  publishConfig: {
+    access: "public"
+  },
   files: [
     "dist"
   ],
   scripts: {
-    build: "tsup src/index.ts --format esm,cjs --dts",
+    build: "tsup src/index.ts --format esm,cjs --dts --external playwright",
     dev: "tsup src/index.ts --format esm,cjs --dts --watch",
     lint: "tsc --noEmit --project tsconfig.lint.json",
     test: "vitest run",
@@ -723,8 +741,18 @@ var package_default = {
   dependencies: {
     "fast-json-patch": "^3.1.1"
   },
+  peerDependencies: {
+    playwright: ">=1.40.0"
+  },
+  peerDependenciesMeta: {
+    playwright: {
+      optional: true
+    }
+  },
   devDependencies: {
+    "@types/node": "^25.0.3",
     "openapi-typescript": "^7.4.4",
+    playwright: "^1.49.0",
     tsup: "^8.2.4",
     typescript: "^5.6.3",
     vitest: "^2.1.4",
@@ -761,6 +789,22 @@ function asModelId(value) {
 function asTierCode(value) {
   return value;
 }
+var SubscriptionStatuses = {
+  Active: "active",
+  Trialing: "trialing",
+  PastDue: "past_due",
+  Canceled: "canceled",
+  Unpaid: "unpaid",
+  Incomplete: "incomplete",
+  IncompleteExpired: "incomplete_expired",
+  Paused: "paused"
+};
+var BillingProviders = {
+  Stripe: "stripe",
+  Crypto: "crypto",
+  AppStore: "app_store",
+  External: "external"
+};
 function createUsage(inputTokens, outputTokens, totalTokens) {
   return {
     inputTokens,
@@ -1278,8 +1322,8 @@ function parseToolArgs(call, schema) {
       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}`;
+          const path2 = e.path.length > 0 ? `${e.path.join(".")}: ` : "";
+          return `${path2}${e.message}`;
         }).join("; ");
         message = issues;
       } else {
@@ -1403,7 +1447,7 @@ var ToolRegistry = class {
         result
       };
     } catch (err) {
-      const isRetryable = err instanceof ToolArgsError;
+      const isRetryable = err instanceof ToolArgsError || err instanceof ToolArgumentError;
       const errorMessage = err instanceof Error ? err.message : String(err);
       return {
         toolCallId: call.id,
@@ -1923,6 +1967,7 @@ function mapNDJSONResponseEvent(line, requestId) {
   }
   const toolCallDelta = extractToolCallDelta(parsed, type);
   const toolCalls = extractToolCalls(parsed, type);
+  const toolResult = extractToolResult(parsed, type);
   return {
     type,
     event: recordType2,
@@ -1930,6 +1975,7 @@ function mapNDJSONResponseEvent(line, requestId) {
     textDelta,
     toolCallDelta,
     toolCalls,
+    toolResult,
     responseId,
     model,
     stopReason,
@@ -1993,6 +2039,15 @@ function extractToolCalls(payload, type) {
   }
   return void 0;
 }
+function extractToolResult(payload, type) {
+  if (type !== "tool_use_stop") {
+    return void 0;
+  }
+  if ("tool_result" in payload) {
+    return payload.tool_result;
+  }
+  return void 0;
+}
 function normalizeToolCalls(toolCalls) {
   const validToolTypes = /* @__PURE__ */ new Set([
     "function",
@@ -3403,8 +3458,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path, errorMaps, issueData } = params;
-  const fullPath = [...path, ...issueData.path || []];
+  const { data, path: path2, errorMaps, issueData } = params;
+  const fullPath = [...path2, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -3520,11 +3575,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path, key) {
+  constructor(parent, value, path2, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path;
+    this._path = path2;
     this._key = key;
   }
   get path() {
@@ -7357,11 +7412,18 @@ var RunsClient = class {
     this.metrics = cfg.metrics;
     this.trace = cfg.trace;
   }
+  applyCustomerHeader(headers, customerId) {
+    const trimmed = customerId?.trim();
+    if (trimmed) {
+      headers[CUSTOMER_ID_HEADER] = trimmed;
+    }
+  }
   async create(spec, options = {}) {
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
     const authHeaders = await this.auth.authForResponses();
     const headers = { ...options.headers || {} };
+    this.applyCustomerHeader(headers, options.customerId);
     const payload = { spec };
     if (options.idempotencyKey?.trim()) {
       payload.options = { idempotency_key: options.idempotencyKey.trim() };
@@ -7418,10 +7480,12 @@ var RunsClient = class {
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
     const authHeaders = await this.auth.authForResponses();
-    const path = runByIdPath(runId);
-    const out = await this.http.json(path, {
+    const path2 = runByIdPath(runId);
+    const headers = { ...options.headers || {} };
+    this.applyCustomerHeader(headers, options.customerId);
+    const out = await this.http.json(path2, {
       method: "GET",
-      headers: options.headers,
+      headers,
       signal: options.signal,
       apiKey: authHeaders.apiKey,
       accessToken: authHeaders.accessToken,
@@ -7430,7 +7494,7 @@ var RunsClient = class {
       retry: options.retry,
       metrics,
       trace,
-      context: { method: "GET", path }
+      context: { method: "GET", path: path2 }
     });
     return {
       ...out,
@@ -7454,9 +7518,10 @@ var RunsClient = class {
     if (options.wait === false) {
       params.set("wait", "0");
     }
-    const path = params.toString() ? `${basePath}?${params}` : basePath;
+    const path2 = params.toString() ? `${basePath}?${params}` : basePath;
     const headers = { ...options.headers || {} };
-    const resp = await this.http.request(path, {
+    this.applyCustomerHeader(headers, options.customerId);
+    const resp = await this.http.request(path2, {
       method: "GET",
       headers,
       signal: options.signal,
@@ -7507,10 +7572,12 @@ var RunsClient = class {
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
     const authHeaders = await this.auth.authForResponses();
-    const path = runToolResultsPath(runId);
-    const out = await this.http.json(path, {
+    const path2 = runToolResultsPath(runId);
+    const headers = { ...options.headers || {} };
+    this.applyCustomerHeader(headers, options.customerId);
+    const out = await this.http.json(path2, {
       method: "POST",
-      headers: options.headers,
+      headers,
       body: req,
       signal: options.signal,
       apiKey: authHeaders.apiKey,
@@ -7520,7 +7587,7 @@ var RunsClient = class {
       retry: options.retry,
       metrics,
       trace,
-      context: { method: "POST", path }
+      context: { method: "POST", path: path2 }
     });
     return out;
   }
@@ -7528,10 +7595,12 @@ var RunsClient = class {
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
     const authHeaders = await this.auth.authForResponses();
-    const path = runPendingToolsPath(runId);
-    const out = await this.http.json(path, {
+    const path2 = runPendingToolsPath(runId);
+    const headers = { ...options.headers || {} };
+    this.applyCustomerHeader(headers, options.customerId);
+    const out = await this.http.json(path2, {
       method: "GET",
-      headers: options.headers,
+      headers,
       signal: options.signal,
       apiKey: authHeaders.apiKey,
       accessToken: authHeaders.accessToken,
@@ -7540,7 +7609,7 @@ var RunsClient = class {
       retry: options.retry,
       metrics,
       trace,
-      context: { method: "GET", path }
+      context: { method: "GET", path: path2 }
     });
     return {
       ...out,
@@ -7569,12 +7638,17 @@ var WorkflowsClient = class {
     const metrics = mergeMetrics(this.metrics, options.metrics);
     const trace = mergeTrace(this.trace, options.trace);
     const authHeaders = await this.auth.authForResponses();
+    const headers = { ...options.headers || {} };
+    const customerId = options.customerId?.trim();
+    if (customerId) {
+      headers[CUSTOMER_ID_HEADER] = customerId;
+    }
     try {
       const out = await this.http.json(
         WORKFLOWS_COMPILE_PATH,
         {
           method: "POST",
-          headers: options.headers,
+          headers,
           body: spec,
           signal: options.signal,
           apiKey: authHeaders.apiKey,
@@ -7725,9 +7799,6 @@ var CustomersClient = class {
    */
   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");
     }
@@ -7768,9 +7839,6 @@ var CustomersClient = class {
    */
   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");
     }
@@ -7788,7 +7856,7 @@ var CustomersClient = class {
     return response.customer;
   }
   /**
-   * Link an end-user identity (provider + subject) to a customer found by email.
+   * Link a customer identity (provider + subject) to a customer found by email.
    * Used when a customer subscribes via Stripe Checkout (email only) and later authenticates to the app.
    *
    * This is a user self-service operation that works with publishable keys,
@@ -7813,12 +7881,11 @@ var CustomersClient = class {
     if (!request.subject?.trim()) {
       throw new ConfigError("subject is required");
     }
-    const response = await this.http.json("/customers/claim", {
+    await this.http.request("/customers/claim", {
       method: "POST",
       body: request,
       apiKey: this.apiKey
     });
-    return response.customer;
   }
   /**
    * Delete a customer by ID.
@@ -7834,18 +7901,21 @@ var CustomersClient = class {
     });
   }
   /**
-   * Create a Stripe checkout session for a customer.
+   * Create a Stripe checkout session for a customer subscription.
    */
-  async createCheckoutSession(customerId, request) {
+  async subscribe(customerId, request) {
     this.ensureSecretKey();
     if (!customerId?.trim()) {
       throw new ConfigError("customerId is required");
     }
+    if (!request.tier_id?.trim()) {
+      throw new ConfigError("tier_id 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`,
+      `/customers/${customerId}/subscribe`,
       {
         method: "POST",
         body: request,
@@ -7854,20 +7924,34 @@ var CustomersClient = class {
     );
   }
   /**
-   * Get the subscription status for a customer.
+   * Get the subscription details for a customer.
    */
   async getSubscription(customerId) {
     this.ensureSecretKey();
     if (!customerId?.trim()) {
       throw new ConfigError("customerId is required");
     }
-    return await this.http.json(
+    const response = await this.http.json(
       `/customers/${customerId}/subscription`,
       {
         method: "GET",
         apiKey: this.apiKey
       }
     );
+    return response.subscription;
+  }
+  /**
+   * Cancel a customer's subscription at period end.
+   */
+  async unsubscribe(customerId) {
+    this.ensureSecretKey();
+    if (!customerId?.trim()) {
+      throw new ConfigError("customerId is required");
+    }
+    await this.http.request(`/customers/${customerId}/subscription`, {
+      method: "DELETE",
+      apiKey: this.apiKey
+    });
   }
 };
 
@@ -7969,903 +8053,1908 @@ var ModelsClient = class {
     if (params.capability) {
       qs.set("capability", params.capability);
     }
-    const path = qs.toString() ? `/models?${qs.toString()}` : "/models";
-    const resp = await this.http.json(path, { method: "GET" });
+    const path2 = qs.toString() ? `/models?${qs.toString()}` : "/models";
+    const resp = await this.http.json(path2, { method: "GET" });
     return resp.models;
   }
 };
 
-// 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://"
-      );
+// src/images.ts
+var IMAGES_PATH = "/images/generate";
+var ImagesClient = class {
+  constructor(http, auth) {
+    this.http = http;
+    this.auth = auth;
+  }
+  /**
+   * Generate images from a text prompt.
+   *
+   * By default, returns URLs (requires storage configuration).
+   * Use response_format: "b64_json" for testing without storage.
+   *
+   * @param request - Image generation request (model optional if tier defines default)
+   * @returns Generated images with URLs or base64 data
+   * @throws {Error} If prompt is empty
+   */
+  async generate(request) {
+    if (!request.prompt?.trim()) {
+      throw new Error("prompt is required");
     }
-    this.baseUrl = resolvedBase;
-    this.apiKey = cfg.apiKey ? parseApiKey(cfg.apiKey) : void 0;
-    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;
+    const auth = await this.auth.authForResponses();
+    return await this.http.json(IMAGES_PATH, {
+      method: "POST",
+      body: request,
+      apiKey: auth.apiKey,
+      accessToken: auth.accessToken
+    });
   }
-  async request(path, options = {}) {
-    const fetchFn = this.fetchImpl ?? globalThis.fetch;
-    if (!fetchFn) {
-      throw new ConfigError(
-        "fetch is not available; provide a fetch implementation"
-      );
+};
+
+// src/sessions/types.ts
+function asSessionId(value) {
+  return value;
+}
+function generateSessionId() {
+  return crypto.randomUUID();
+}
+
+// src/sessions/stores/memory_store.ts
+var MemorySessionStore = class {
+  constructor() {
+    this.sessions = /* @__PURE__ */ new Map();
+  }
+  async load(id) {
+    const state = this.sessions.get(id);
+    if (!state) return null;
+    return structuredClone(state);
+  }
+  async save(state) {
+    this.sessions.set(state.id, structuredClone(state));
+  }
+  async delete(id) {
+    this.sessions.delete(id);
+  }
+  async list() {
+    return Array.from(this.sessions.keys());
+  }
+  async close() {
+    this.sessions.clear();
+  }
+  /**
+   * Get the number of sessions in the store.
+   * Useful for testing.
+   */
+  get size() {
+    return this.sessions.size;
+  }
+};
+function createMemorySessionStore() {
+  return new MemorySessionStore();
+}
+
+// src/sessions/local_session.ts
+var LocalSession = class _LocalSession {
+  constructor(client, store, options, existingState) {
+    this.type = "local";
+    this.messages = [];
+    this.artifacts = /* @__PURE__ */ new Map();
+    this.nextSeq = 1;
+    this.currentEvents = [];
+    this.currentUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      llmCalls: 0,
+      toolCalls: 0
+    };
+    this.client = client;
+    this.store = store;
+    this.toolRegistry = options.toolRegistry;
+    this.defaultModel = options.defaultModel;
+    this.defaultProvider = options.defaultProvider;
+    this.defaultTools = options.defaultTools;
+    this.metadata = options.metadata || {};
+    if (existingState) {
+      this.id = existingState.id;
+      this.messages = existingState.messages.map((m) => ({
+        ...m,
+        createdAt: new Date(m.createdAt)
+      }));
+      this.artifacts = new Map(Object.entries(existingState.artifacts));
+      this.nextSeq = this.messages.length + 1;
+      this.createdAt = new Date(existingState.createdAt);
+      this.updatedAt = new Date(existingState.updatedAt);
+    } else {
+      this.id = options.sessionId || generateSessionId();
+      this.createdAt = /* @__PURE__ */ new Date();
+      this.updatedAt = /* @__PURE__ */ new Date();
     }
-    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 || {}
+  }
+  /**
+   * Create a new local session.
+   *
+   * @param client - ModelRelay client
+   * @param options - Session configuration
+   * @returns A new LocalSession instance
+   */
+  static create(client, options = {}) {
+    const store = createStore(options.persistence || "memory", options.storagePath);
+    return new _LocalSession(client, store, options);
+  }
+  /**
+   * Resume an existing session from storage.
+   *
+   * @param client - ModelRelay client
+   * @param sessionId - ID of the session to resume
+   * @param options - Session configuration (must match original persistence settings)
+   * @returns The resumed LocalSession, or null if not found
+   */
+  static async resume(client, sessionId, options = {}) {
+    const id = typeof sessionId === "string" ? asSessionId(sessionId) : sessionId;
+    const store = createStore(options.persistence || "memory", options.storagePath);
+    const state = await store.load(id);
+    if (!state) {
+      await store.close();
+      return null;
+    }
+    return new _LocalSession(client, store, options, state);
+  }
+  get history() {
+    return this.messages;
+  }
+  async run(prompt, options = {}) {
+    const userMessage = this.addMessage({
+      type: "message",
+      role: "user",
+      content: [{ type: "text", text: prompt }]
+    });
+    this.currentEvents = [];
+    this.currentUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      llmCalls: 0,
+      toolCalls: 0
     };
-    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);
+    this.currentRunId = void 0;
+    this.currentNodeId = void 0;
+    this.currentWaiting = void 0;
+    try {
+      const input = this.buildInput();
+      const tools = mergeTools(this.defaultTools, options.tools);
+      const spec = {
+        kind: "workflow.v0",
+        name: `session-${this.id}-turn-${this.nextSeq}`,
+        nodes: [
+          {
+            id: "main",
+            type: "llm.responses",
+            input: {
+              request: {
+                provider: options.provider || this.defaultProvider,
+                model: options.model || this.defaultModel,
+                input,
+                tools
+              },
+              tool_execution: this.toolRegistry ? { mode: "client" } : void 0
+            }
+          }
+        ],
+        outputs: [{ name: "result", from: "main" }]
+      };
+      const run = await this.client.runs.create(spec, {
+        customerId: options.customerId
+      });
+      this.currentRunId = run.run_id;
+      return await this.processRunEvents(options.signal);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      return {
+        status: "error",
+        error: error.message,
+        runId: this.currentRunId || parseRunId("unknown"),
+        usage: this.currentUsage,
+        events: this.currentEvents
+      };
     }
-    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");
+  }
+  async submitToolResults(results) {
+    if (!this.currentRunId || !this.currentNodeId || !this.currentWaiting) {
+      throw new Error("No pending tool calls to submit results for");
     }
-    const accessToken = options.accessToken ?? this.accessToken;
-    if (accessToken) {
-      const bearer = accessToken.toLowerCase().startsWith("bearer ") ? accessToken : `Bearer ${accessToken}`;
-      headers.set("Authorization", bearer);
+    await this.client.runs.submitToolResults(this.currentRunId, {
+      node_id: this.currentNodeId,
+      step: this.currentWaiting.step,
+      request_id: this.currentWaiting.request_id,
+      results: results.map((r) => ({
+        tool_call_id: r.toolCallId,
+        name: r.toolName,
+        output: r.error ? `Error: ${r.error}` : typeof r.result === "string" ? r.result : JSON.stringify(r.result)
+      }))
+    });
+    this.currentWaiting = void 0;
+    return await this.processRunEvents();
+  }
+  getArtifacts() {
+    return new Map(this.artifacts);
+  }
+  async close() {
+    await this.persist();
+    await this.store.close();
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  addMessage(input, runId) {
+    const message = {
+      ...input,
+      seq: this.nextSeq++,
+      createdAt: /* @__PURE__ */ new Date(),
+      runId
+    };
+    this.messages.push(message);
+    this.updatedAt = /* @__PURE__ */ new Date();
+    return message;
+  }
+  buildInput() {
+    return this.messages.map((m) => ({
+      type: m.type,
+      role: m.role,
+      content: m.content,
+      toolCalls: m.toolCalls,
+      toolCallId: m.toolCallId
+    }));
+  }
+  async processRunEvents(signal) {
+    if (!this.currentRunId) {
+      throw new Error("No current run");
     }
-    const apiKey = options.apiKey ?? this.apiKey;
-    if (apiKey) {
-      headers.set("X-ModelRelay-Api-Key", apiKey);
+    const eventStream = await this.client.runs.events(this.currentRunId, {
+      afterSeq: this.currentEvents.length
+    });
+    for await (const event of eventStream) {
+      if (signal?.aborted) {
+        return {
+          status: "canceled",
+          runId: this.currentRunId,
+          usage: this.currentUsage,
+          events: this.currentEvents
+        };
+      }
+      this.currentEvents.push(event);
+      switch (event.type) {
+        case "node_llm_call":
+          this.currentUsage = {
+            ...this.currentUsage,
+            llmCalls: this.currentUsage.llmCalls + 1,
+            inputTokens: this.currentUsage.inputTokens + (event.llm_call.usage?.input_tokens || 0),
+            outputTokens: this.currentUsage.outputTokens + (event.llm_call.usage?.output_tokens || 0),
+            totalTokens: this.currentUsage.totalTokens + (event.llm_call.usage?.total_tokens || 0)
+          };
+          break;
+        case "node_tool_call":
+          this.currentUsage = {
+            ...this.currentUsage,
+            toolCalls: this.currentUsage.toolCalls + 1
+          };
+          break;
+        case "node_waiting":
+          this.currentNodeId = event.node_id;
+          this.currentWaiting = event.waiting;
+          if (this.toolRegistry) {
+            const results = await this.executeTools(event.waiting.pending_tool_calls);
+            return await this.submitToolResults(results);
+          }
+          return {
+            status: "waiting_for_tools",
+            pendingTools: event.waiting.pending_tool_calls.map((tc) => ({
+              toolCallId: tc.tool_call_id,
+              name: tc.name,
+              arguments: tc.arguments
+            })),
+            runId: this.currentRunId,
+            usage: this.currentUsage,
+            events: this.currentEvents
+          };
+        case "run_completed":
+          const runState = await this.client.runs.get(this.currentRunId);
+          const output = extractTextOutput(runState.outputs || {});
+          if (output) {
+            this.addMessage(
+              {
+                type: "message",
+                role: "assistant",
+                content: [{ type: "text", text: output }]
+              },
+              this.currentRunId
+            );
+          }
+          await this.persist();
+          return {
+            status: "complete",
+            output,
+            runId: this.currentRunId,
+            usage: this.currentUsage,
+            events: this.currentEvents
+          };
+        case "run_failed":
+          return {
+            status: "error",
+            error: event.error.message,
+            runId: this.currentRunId,
+            usage: this.currentUsage,
+            events: this.currentEvents
+          };
+        case "run_canceled":
+          return {
+            status: "canceled",
+            error: event.error.message,
+            runId: this.currentRunId,
+            usage: this.currentUsage,
+            events: this.currentEvents
+          };
+      }
     }
-    if (this.clientHeader && !headers.has("X-ModelRelay-Client")) {
-      headers.set("X-ModelRelay-Client", this.clientHeader);
+    return {
+      status: "error",
+      error: "Run event stream ended unexpectedly",
+      runId: this.currentRunId,
+      usage: this.currentUsage,
+      events: this.currentEvents
+    };
+  }
+  async executeTools(pendingTools) {
+    if (!this.toolRegistry) {
+      throw new Error("No tool registry configured");
     }
-    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);
+    const results = [];
+    for (const pending of pendingTools) {
       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 result = await this.toolRegistry.execute({
+          id: pending.tool_call_id,
+          type: "function",
+          function: {
+            name: pending.name,
+            arguments: pending.arguments
           }
-          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;
+        results.push(result);
       } 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 error = err instanceof Error ? err : new Error(String(err));
+        results.push({
+          toolCallId: pending.tool_call_id,
+          toolName: pending.name,
+          result: null,
+          error: error.message
+        });
       }
     }
-    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,
-      raw: true,
-      accept: options.accept || "application/json"
-    });
-    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
-      });
-    }
+    return results;
+  }
+  async persist() {
+    const state = {
+      id: this.id,
+      messages: this.messages.map((m) => ({
+        ...m,
+        createdAt: m.createdAt
+      })),
+      artifacts: Object.fromEntries(this.artifacts),
+      metadata: this.metadata,
+      createdAt: this.createdAt.toISOString(),
+      updatedAt: this.updatedAt.toISOString()
+    };
+    await this.store.save(state);
   }
 };
-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);
+function createStore(persistence, storagePath) {
+  switch (persistence) {
+    case "memory":
+      return createMemorySessionStore();
+    case "file":
+      throw new Error("File persistence not yet implemented");
+    case "sqlite":
+      throw new Error("SQLite persistence not yet implemented");
+    default:
+      throw new Error(`Unknown persistence mode: ${persistence}`);
   }
-  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;
-  }
-  if (status >= 500 && status < 600) {
-    return method !== "POST" || retryPost;
+function mergeTools(defaults, overrides) {
+  if (!defaults && !overrides) return void 0;
+  if (!defaults) return overrides;
+  if (!overrides) return defaults;
+  const merged = /* @__PURE__ */ new Map();
+  for (const tool of defaults) {
+    if (tool.type === "function" && tool.function) {
+      merged.set(tool.function.name, tool);
+    }
   }
-  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;
+  for (const tool of overrides) {
+    if (tool.type === "function" && tool.function) {
+      merged.set(tool.function.name, tool);
     }
-    src.addEventListener(
-      "abort",
-      () => controller.abort(src.reason),
-      { once: true }
-    );
   }
-  return controller.signal;
+  return Array.from(merged.values());
 }
-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;
+function extractTextOutput(outputs) {
+  const result = outputs.result;
+  if (typeof result === "string") return result;
+  if (result && typeof result === "object") {
+    const resp = result;
+    if (Array.isArray(resp.output)) {
+      const textParts = resp.output.filter((item) => item?.type === "message" && item?.role === "assistant").flatMap(
+        (item) => (item.content || []).filter((c) => c?.type === "text").map((c) => c.text)
+      );
+      if (textParts.length > 0) {
+        return textParts.join("\n");
+      }
+    }
+    if (Array.isArray(resp.content)) {
+      const textParts = resp.content.filter((c) => c?.type === "text").map((c) => c.text);
+      if (textParts.length > 0) {
+        return textParts.join("\n");
+      }
     }
   }
-  return normalized;
+  return void 0;
 }
-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 createLocalSession(client, options = {}) {
+  return LocalSession.create(client, options);
 }
-function classifyTransportErrorKind(err, connectTimedOut, requestTimedOut) {
-  if (connectTimedOut) return "connect";
-  if (requestTimedOut) return "timeout";
-  if (err instanceof DOMException && err.name === "AbortError") {
-    return requestTimedOut ? "timeout" : "request";
+
+// src/sessions/remote_session.ts
+var RemoteSession = class _RemoteSession {
+  constructor(client, http, sessionData, options = {}) {
+    this.type = "remote";
+    this.messages = [];
+    this.artifacts = /* @__PURE__ */ new Map();
+    this.nextSeq = 1;
+    this.currentEvents = [];
+    this.currentUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      llmCalls: 0,
+      toolCalls: 0
+    };
+    this.client = client;
+    this.http = http;
+    this.id = asSessionId(sessionData.id);
+    this.metadata = sessionData.metadata;
+    this.endUserId = sessionData.end_user_id || options.endUserId;
+    this.createdAt = new Date(sessionData.created_at);
+    this.updatedAt = new Date(sessionData.updated_at);
+    this.toolRegistry = options.toolRegistry;
+    this.defaultModel = options.defaultModel;
+    this.defaultProvider = options.defaultProvider;
+    this.defaultTools = options.defaultTools;
+    if ("messages" in sessionData && sessionData.messages) {
+      this.messages = sessionData.messages.map((m) => ({
+        type: "message",
+        role: m.role,
+        content: m.content,
+        seq: m.seq,
+        createdAt: new Date(m.created_at),
+        runId: m.run_id ? parseRunId(m.run_id) : void 0
+      }));
+      this.nextSeq = this.messages.length + 1;
+    }
   }
-  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
+  /**
+   * Create a new remote session on the server.
+   *
+   * @param client - ModelRelay client
+   * @param options - Session configuration
+   * @returns A new RemoteSession instance
+   */
+  static async create(client, options = {}) {
+    const http = getHTTPClient(client);
+    const response = await http.request("/sessions", {
+      method: "POST",
+      body: {
+        end_user_id: options.endUserId,
+        metadata: options.metadata || {}
+      }
     });
+    const data = await response.json();
+    return new _RemoteSession(client, http, data, options);
   }
-  trace?.requestFinish?.({
-    context: info.context,
-    status: info.status,
-    error: info.error,
-    retries,
-    latencyMs
-  });
-}
-function withRequestId(context, headers) {
-  const requestId = headers.get("X-ModelRelay-Request-Id") || headers.get("X-Request-Id") || context.requestId;
-  if (!requestId) return context;
-  return { ...context, requestId };
-}
-
-// src/customer_scoped.ts
-function normalizeCustomerId(customerId) {
-  const trimmed = customerId?.trim?.() ? customerId.trim() : "";
-  if (!trimmed) {
-    throw new ConfigError("customerId is required");
-  }
-  return trimmed;
-}
-function mergeCustomerOptions(customerId, options = {}) {
-  if (options.customerId && options.customerId !== customerId) {
-    throw new ConfigError("customerId mismatch", {
-      expected: customerId,
-      received: options.customerId
+  /**
+   * Get an existing remote session by ID.
+   *
+   * @param client - ModelRelay client
+   * @param sessionId - ID of the session to retrieve
+   * @param options - Optional configuration (toolRegistry, defaults)
+   * @returns The RemoteSession instance
+   */
+  static async get(client, sessionId, options = {}) {
+    const http = getHTTPClient(client);
+    const id = typeof sessionId === "string" ? sessionId : String(sessionId);
+    const response = await http.request(`/sessions/${id}`, {
+      method: "GET"
     });
+    const data = await response.json();
+    return new _RemoteSession(client, http, data, options);
   }
-  return { ...options, customerId };
-}
-var CustomerResponsesClient = class {
-  constructor(base, customerId) {
-    this.customerId = normalizeCustomerId(customerId);
-    this.base = base;
+  /**
+   * List remote sessions.
+   *
+   * @param client - ModelRelay client
+   * @param options - List options
+   * @returns Paginated list of session info
+   */
+  static async list(client, options = {}) {
+    const http = getHTTPClient(client);
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    if (options.endUserId) params.set("end_user_id", options.endUserId);
+    const response = await http.request(
+      `/sessions${params.toString() ? `?${params.toString()}` : ""}`,
+      { method: "GET" }
+    );
+    const data = await response.json();
+    return {
+      sessions: data.sessions.map((s) => ({
+        id: asSessionId(s.id),
+        messageCount: s.message_count,
+        metadata: s.metadata,
+        createdAt: new Date(s.created_at),
+        updatedAt: new Date(s.updated_at)
+      })),
+      nextCursor: data.next_cursor
+    };
   }
-  get id() {
-    return this.customerId;
+  /**
+   * Delete a remote session.
+   *
+   * @param client - ModelRelay client
+   * @param sessionId - ID of the session to delete
+   */
+  static async delete(client, sessionId) {
+    const http = getHTTPClient(client);
+    const id = typeof sessionId === "string" ? sessionId : String(sessionId);
+    await http.request(`/sessions/${id}`, {
+      method: "DELETE"
+    });
   }
-  new() {
-    return this.base.new().customerId(this.customerId);
+  // ============================================================================
+  // Session Interface Implementation
+  // ============================================================================
+  /**
+   * Full conversation history (read-only).
+   */
+  get history() {
+    return this.messages;
   }
-  ensureRequestCustomer(request) {
-    const req = asInternal(request);
-    const reqCustomer = req.options.customerId;
-    if (reqCustomer && reqCustomer !== this.customerId) {
-      throw new ConfigError("customerId mismatch", {
-        expected: this.customerId,
-        received: reqCustomer
+  /**
+   * Execute a prompt as a new turn in this session.
+   */
+  async run(prompt, options = {}) {
+    const userMessage = this.addMessage({
+      type: "message",
+      role: "user",
+      content: [{ type: "text", text: prompt }]
+    });
+    this.resetRunState();
+    try {
+      const input = this.buildInput();
+      const tools = mergeTools2(this.defaultTools, options.tools);
+      const spec = {
+        kind: "workflow.v0",
+        name: `session-${this.id}-turn-${this.nextSeq}`,
+        nodes: [
+          {
+            id: "main",
+            type: "llm.responses",
+            input: {
+              request: {
+                provider: options.provider || this.defaultProvider,
+                model: options.model || this.defaultModel,
+                input,
+                tools
+              },
+              tool_execution: this.toolRegistry ? { mode: "client" } : void 0
+            }
+          }
+        ],
+        outputs: [{ name: "result", from: "main" }]
+      };
+      const run = await this.client.runs.create(spec, {
+        customerId: options.customerId || this.endUserId
       });
+      this.currentRunId = run.run_id;
+      return await this.processRunEvents(options.signal);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      return {
+        status: "error",
+        error: error.message,
+        runId: this.currentRunId || parseRunId("unknown"),
+        usage: { ...this.currentUsage },
+        events: [...this.currentEvents]
+      };
     }
   }
-  async create(request, options = {}) {
-    this.ensureRequestCustomer(request);
-    return this.base.create(request, mergeCustomerOptions(this.customerId, options));
-  }
-  async stream(request, options = {}) {
-    this.ensureRequestCustomer(request);
-    return this.base.stream(request, mergeCustomerOptions(this.customerId, options));
-  }
-  async streamJSON(request, options = {}) {
-    this.ensureRequestCustomer(request);
-    return this.base.streamJSON(
-      request,
-      mergeCustomerOptions(this.customerId, options)
-    );
+  /**
+   * Submit tool results for a waiting run.
+   */
+  async submitToolResults(results) {
+    if (!this.currentRunId || !this.currentNodeId || !this.currentWaiting) {
+      throw new Error("No pending tool calls to submit results for");
+    }
+    await this.client.runs.submitToolResults(this.currentRunId, {
+      node_id: this.currentNodeId,
+      step: this.currentWaiting.step,
+      request_id: this.currentWaiting.request_id,
+      results: results.map((r) => ({
+        tool_call_id: r.toolCallId,
+        name: r.toolName,
+        output: r.error ? `Error: ${r.error}` : typeof r.result === "string" ? r.result : JSON.stringify(r.result)
+      }))
+    });
+    this.currentWaiting = void 0;
+    return await this.processRunEvents();
   }
-  async text(system, user, options = {}) {
-    return this.base.textForCustomer(
-      this.customerId,
-      system,
-      user,
-      mergeCustomerOptions(this.customerId, options)
-    );
+  /**
+   * Get all artifacts produced during this session.
+   */
+  getArtifacts() {
+    return new Map(this.artifacts);
   }
-  async streamTextDeltas(system, user, options = {}) {
-    return this.base.streamTextDeltasForCustomer(
-      this.customerId,
-      system,
-      user,
-      mergeCustomerOptions(this.customerId, options)
-    );
+  /**
+   * Close the session (no-op for remote sessions).
+   */
+  async close() {
   }
-};
-var CustomerScopedModelRelay = class {
-  constructor(responses, customerId, baseUrl) {
-    const normalized = normalizeCustomerId(customerId);
-    this.responses = new CustomerResponsesClient(responses, normalized);
-    this.customerId = normalized;
-    this.baseUrl = baseUrl;
+  /**
+   * Refresh the session state from the server.
+   */
+  async refresh() {
+    const response = await this.http.request(`/sessions/${this.id}`, {
+      method: "GET"
+    });
+    const data = await response.json();
+    this.metadata = data.metadata;
+    this.updatedAt = new Date(data.updated_at);
+    if (data.messages) {
+      this.messages = data.messages.map((m) => ({
+        type: "message",
+        role: m.role,
+        content: m.content,
+        seq: m.seq,
+        createdAt: new Date(m.created_at),
+        runId: m.run_id ? parseRunId(m.run_id) : void 0
+      }));
+      this.nextSeq = this.messages.length + 1;
+    }
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  addMessage(input, runId) {
+    const message = {
+      ...input,
+      seq: this.nextSeq++,
+      createdAt: /* @__PURE__ */ new Date(),
+      runId
+    };
+    this.messages.push(message);
+    this.updatedAt = /* @__PURE__ */ new Date();
+    return message;
+  }
+  buildInput() {
+    return this.messages.map((m) => ({
+      type: m.type,
+      role: m.role,
+      content: m.content,
+      toolCalls: m.toolCalls,
+      toolCallId: m.toolCallId
+    }));
   }
-};
-
-// src/token_providers.ts
-function isReusable(token) {
-  if (!token.token) {
-    return false;
+  resetRunState() {
+    this.currentRunId = void 0;
+    this.currentNodeId = void 0;
+    this.currentWaiting = void 0;
+    this.currentEvents = [];
+    this.currentUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      llmCalls: 0,
+      toolCalls: 0
+    };
   }
-  return token.expiresAt.getTime() - Date.now() > 6e4;
-}
-var FrontendTokenProvider = class {
-  constructor(cfg) {
-    const publishableKey = parsePublishableKey(cfg.publishableKey);
-    const http = new HTTPClient({
-      baseUrl: cfg.baseUrl || DEFAULT_BASE_URL,
-      fetchImpl: cfg.fetch,
-      clientHeader: cfg.clientHeader || DEFAULT_CLIENT_HEADER,
-      apiKey: publishableKey
+  async processRunEvents(signal) {
+    if (!this.currentRunId) {
+      throw new Error("No current run");
+    }
+    const eventStream = await this.client.runs.events(this.currentRunId, {
+      afterSeq: this.currentEvents.length
     });
-    this.publishableKey = publishableKey;
-    this.customer = cfg.customer;
-    this.auth = new AuthClient(http, { apiKey: publishableKey, customer: cfg.customer });
-  }
-  async getToken() {
-    if (!this.customer?.provider || !this.customer?.subject) {
-      throw new ConfigError("customer.provider and customer.subject are required");
+    for await (const event of eventStream) {
+      if (signal?.aborted) {
+        return {
+          status: "canceled",
+          runId: this.currentRunId,
+          usage: { ...this.currentUsage },
+          events: [...this.currentEvents]
+        };
+      }
+      this.currentEvents.push(event);
+      switch (event.type) {
+        case "node_llm_call":
+          this.currentUsage = {
+            ...this.currentUsage,
+            llmCalls: this.currentUsage.llmCalls + 1,
+            inputTokens: this.currentUsage.inputTokens + (event.llm_call.usage?.input_tokens || 0),
+            outputTokens: this.currentUsage.outputTokens + (event.llm_call.usage?.output_tokens || 0),
+            totalTokens: this.currentUsage.totalTokens + (event.llm_call.usage?.total_tokens || 0)
+          };
+          break;
+        case "node_tool_call":
+          this.currentUsage = {
+            ...this.currentUsage,
+            toolCalls: this.currentUsage.toolCalls + 1
+          };
+          break;
+        case "node_waiting":
+          this.currentNodeId = event.node_id;
+          this.currentWaiting = event.waiting;
+          if (this.toolRegistry && event.waiting.reason === "tool_results" && event.waiting.pending_tool_calls && event.waiting.pending_tool_calls.length > 0) {
+            const results = await this.executeToolsLocally(
+              event.waiting.pending_tool_calls
+            );
+            if (results) {
+              return this.submitToolResults(results);
+            }
+          }
+          if (event.waiting.reason === "tool_results" && event.waiting.pending_tool_calls) {
+            return {
+              status: "waiting_for_tools",
+              pendingTools: event.waiting.pending_tool_calls.map(
+                (tc) => ({
+                  toolCallId: tc.tool_call_id,
+                  name: tc.name,
+                  arguments: tc.arguments
+                })
+              ),
+              runId: this.currentRunId,
+              usage: { ...this.currentUsage },
+              events: [...this.currentEvents]
+            };
+          }
+          break;
+        case "run_completed": {
+          const runState2 = await this.client.runs.get(this.currentRunId);
+          let output2;
+          if (runState2.outputs && Array.isArray(runState2.outputs)) {
+            output2 = runState2.outputs.filter((o) => o.type === "text").map((o) => o.text || "").join("");
+          }
+          if (output2) {
+            this.addMessage(
+              {
+                type: "message",
+                role: "assistant",
+                content: [{ type: "text", text: output2 }]
+              },
+              this.currentRunId
+            );
+          }
+          return {
+            status: "complete",
+            output: output2,
+            runId: this.currentRunId,
+            usage: { ...this.currentUsage },
+            events: [...this.currentEvents]
+          };
+        }
+        case "run_failed":
+          return {
+            status: "error",
+            error: "Run failed",
+            runId: this.currentRunId,
+            usage: { ...this.currentUsage },
+            events: [...this.currentEvents]
+          };
+        case "run_canceled":
+          return {
+            status: "canceled",
+            runId: this.currentRunId,
+            usage: { ...this.currentUsage },
+            events: [...this.currentEvents]
+          };
+      }
     }
-    const reqBase = {
-      publishableKey: this.publishableKey,
-      identityProvider: this.customer.provider,
-      identitySubject: this.customer.subject,
-      deviceId: this.customer.deviceId,
-      ttlSeconds: this.customer.ttlSeconds
-    };
-    let token;
-    if (this.customer.email) {
-      const req = {
-        ...reqBase,
-        email: this.customer.email
-      };
-      token = await this.auth.frontendTokenAutoProvision(req);
-    } else {
-      const req = reqBase;
-      token = await this.auth.frontendToken(req);
+    const runState = await this.client.runs.get(this.currentRunId);
+    let output;
+    if (runState.outputs && Array.isArray(runState.outputs)) {
+      output = runState.outputs.filter((o) => o.type === "text").map((o) => o.text || "").join("");
     }
-    if (!token.token) {
-      throw new ConfigError("frontend token exchange returned an empty token");
+    if (output) {
+      this.addMessage(
+        {
+          type: "message",
+          role: "assistant",
+          content: [{ type: "text", text: output }]
+        },
+        this.currentRunId
+      );
     }
-    return token.token;
-  }
-};
-var CustomerTokenProvider = class {
-  constructor(cfg) {
-    const key = parseSecretKey(cfg.secretKey);
-    const http = new HTTPClient({
-      baseUrl: cfg.baseUrl || DEFAULT_BASE_URL,
-      fetchImpl: cfg.fetch,
-      clientHeader: cfg.clientHeader || DEFAULT_CLIENT_HEADER,
-      apiKey: key
-    });
-    this.auth = new AuthClient(http, { apiKey: key });
-    this.req = cfg.request;
+    return {
+      status: "complete",
+      output,
+      runId: this.currentRunId,
+      usage: { ...this.currentUsage },
+      events: [...this.currentEvents]
+    };
   }
-  async getToken() {
-    if (this.cached && isReusable(this.cached)) {
-      return this.cached.token;
+  async executeToolsLocally(toolCalls) {
+    if (!this.toolRegistry) return null;
+    for (const tc of toolCalls) {
+      if (!this.toolRegistry.has(tc.name)) {
+        return null;
+      }
     }
-    const token = await this.auth.customerToken(this.req);
-    this.cached = token;
-    return token.token;
+    const results = [];
+    for (const tc of toolCalls) {
+      const toolCall = {
+        id: tc.tool_call_id,
+        type: "function",
+        function: {
+          name: tc.name,
+          arguments: tc.arguments
+        }
+      };
+      const result = await this.toolRegistry.execute(toolCall);
+      results.push(result);
+    }
+    return results;
   }
 };
-var OIDCExchangeTokenProvider = class {
-  constructor(cfg) {
-    const apiKey = parseApiKey(cfg.apiKey);
-    const http = new HTTPClient({
-      baseUrl: cfg.baseUrl || DEFAULT_BASE_URL,
-      fetchImpl: cfg.fetch,
-      clientHeader: cfg.clientHeader || DEFAULT_CLIENT_HEADER,
-      apiKey
-    });
-    this.auth = new AuthClient(http, { apiKey });
-    this.idTokenProvider = cfg.idTokenProvider;
-    this.request = { idToken: "", projectId: cfg.projectId };
-  }
-  async getToken() {
-    if (this.cached && isReusable(this.cached)) {
-      return this.cached.token;
+function getHTTPClient(client) {
+  return client.http;
+}
+function mergeTools2(defaults, overrides) {
+  if (!defaults && !overrides) return void 0;
+  if (!defaults) return overrides;
+  if (!overrides) return defaults;
+  const merged = /* @__PURE__ */ new Map();
+  for (const tool of defaults) {
+    if (tool.type === "function" && tool.function) {
+      merged.set(tool.function.name, tool);
     }
-    const idToken = (await this.idTokenProvider())?.trim();
-    if (!idToken) {
-      throw new ConfigError("idTokenProvider returned an empty id_token");
+  }
+  for (const tool of overrides) {
+    if (tool.type === "function" && tool.function) {
+      merged.set(tool.function.name, tool);
     }
-    const token = await this.auth.oidcExchange({ ...this.request, idToken });
-    this.cached = token;
-    return token.token;
   }
-};
+  return Array.from(merged.values());
+}
 
-// src/device_flow.ts
-async function startOAuthDeviceAuthorization(req) {
-  const deviceAuthorizationEndpoint = req.deviceAuthorizationEndpoint?.trim();
-  if (!deviceAuthorizationEndpoint) {
-    throw new ConfigError("deviceAuthorizationEndpoint is required");
+// src/sessions/client.ts
+var SessionsClient = class {
+  constructor(modelRelay, http, auth) {
+    this.modelRelay = modelRelay;
+    this.http = http;
+    this.auth = auth;
   }
-  const clientId = req.clientId?.trim();
-  if (!clientId) {
-    throw new ConfigError("clientId is required");
+  // ============================================================================
+  // Local Sessions (Client-Managed)
+  // ============================================================================
+  /**
+   * Create a new local session.
+   *
+   * Local sessions keep history on the client side with optional persistence.
+   * Use for privacy-sensitive workflows or offline-capable agents.
+   *
+   * @param options - Session configuration
+   * @returns A new LocalSession instance
+   *
+   * @example
+   * ```typescript
+   * const session = client.sessions.createLocal({
+   *   toolRegistry: createLocalFSTools({ root: process.cwd() }),
+   *   persistence: "memory", // or "file", "sqlite"
+   * });
+   *
+   * const result = await session.run("Create a hello world file");
+   * ```
+   */
+  createLocal(options = {}) {
+    return createLocalSession(this.modelRelay, options);
   }
-  const form = new URLSearchParams();
-  form.set("client_id", clientId);
-  if (req.scope?.trim()) {
-    form.set("scope", req.scope.trim());
+  /**
+   * Resume an existing local session from storage.
+   *
+   * @param sessionId - ID of the session to resume
+   * @param options - Session configuration (must match original persistence settings)
+   * @returns The resumed LocalSession, or null if not found
+   *
+   * @example
+   * ```typescript
+   * const session = await client.sessions.resumeLocal("session-id", {
+   *   persistence: "sqlite",
+   * });
+   *
+   * if (session) {
+   *   console.log(`Resumed session with ${session.history.length} messages`);
+   *   const result = await session.run("Continue where we left off");
+   * }
+   * ```
+   */
+  async resumeLocal(sessionId, options = {}) {
+    return LocalSession.resume(this.modelRelay, sessionId, options);
   }
-  if (req.audience?.trim()) {
-    form.set("audience", req.audience.trim());
+  // ============================================================================
+  // Remote Sessions (Server-Managed)
+  // ============================================================================
+  /**
+   * Create a new remote session.
+   *
+   * Remote sessions store history on the server for cross-device continuity.
+   * Use for browser-based agents or team collaboration.
+   *
+   * @param options - Session configuration
+   * @returns A new RemoteSession instance
+   *
+   * @example
+   * ```typescript
+   * const session = await client.sessions.create({
+   *   metadata: { name: "Feature implementation" },
+   * });
+   *
+   * const result = await session.run("Implement the login feature");
+   * ```
+   */
+  async create(options = {}) {
+    return RemoteSession.create(this.modelRelay, options);
   }
-  const payload = await postOAuthForm(deviceAuthorizationEndpoint, form, {
-    fetch: req.fetch,
-    signal: req.signal
-  });
-  const deviceCode = String(payload.device_code || "").trim();
-  const userCode = String(payload.user_code || "").trim();
-  const verificationUri = String(payload.verification_uri || payload.verification_uri_complete || "").trim();
-  const verificationUriComplete = String(payload.verification_uri_complete || "").trim() || void 0;
-  const expiresIn = Number(payload.expires_in || 0);
-  const intervalSeconds = Math.max(1, Number(payload.interval || 5));
-  if (!deviceCode || !userCode || !verificationUri || !expiresIn) {
-    throw new TransportError("oauth device authorization returned an invalid response", {
-      kind: "request",
-      cause: payload
+  /**
+   * Get an existing remote session by ID.
+   *
+   * @param sessionId - ID of the session to retrieve
+   * @param options - Optional configuration (toolRegistry, defaults)
+   * @returns The RemoteSession instance
+   *
+   * @example
+   * ```typescript
+   * const session = await client.sessions.get("session-id");
+   * console.log(`Session has ${session.history.length} messages`);
+   * ```
+   */
+  async get(sessionId, options = {}) {
+    return RemoteSession.get(this.modelRelay, sessionId, options);
+  }
+  /**
+   * List remote sessions.
+   *
+   * @param options - List options (limit, cursor, endUserId)
+   * @returns Paginated list of session summaries
+   *
+   * @example
+   * ```typescript
+   * const { sessions, nextCursor } = await client.sessions.list({ limit: 10 });
+   * for (const info of sessions) {
+   *   console.log(`Session ${info.id}: ${info.messageCount} messages`);
+   * }
+   * ```
+   */
+  async list(options = {}) {
+    return RemoteSession.list(this.modelRelay, {
+      limit: options.limit,
+      offset: options.cursor ? parseInt(options.cursor, 10) : void 0,
+      endUserId: options.endUserId
     });
   }
-  return {
-    deviceCode,
-    userCode,
-    verificationUri,
-    verificationUriComplete,
-    expiresAt: new Date(Date.now() + expiresIn * 1e3),
-    intervalSeconds
-  };
-}
-async function pollOAuthDeviceToken(req) {
-  const tokenEndpoint = req.tokenEndpoint?.trim();
-  if (!tokenEndpoint) {
-    throw new ConfigError("tokenEndpoint is required");
-  }
-  const clientId = req.clientId?.trim();
-  if (!clientId) {
-    throw new ConfigError("clientId is required");
+  /**
+   * Delete a remote session.
+   *
+   * Requires a secret key (not publishable key).
+   *
+   * @param sessionId - ID of the session to delete
+   *
+   * @example
+   * ```typescript
+   * await client.sessions.delete("session-id");
+   * ```
+   */
+  async delete(sessionId) {
+    return RemoteSession.delete(this.modelRelay, sessionId);
   }
-  const deviceCode = req.deviceCode?.trim();
-  if (!deviceCode) {
-    throw new ConfigError("deviceCode is required");
+};
+
+// 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 ? parseApiKey(cfg.apiKey) : void 0;
+    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;
   }
-  const deadline = req.deadline ?? new Date(Date.now() + 10 * 60 * 1e3);
-  let intervalMs = Math.max(1, req.intervalSeconds ?? 5) * 1e3;
-  while (true) {
-    if (Date.now() >= deadline.getTime()) {
-      throw new TransportError("oauth device flow timed out", { kind: "timeout" });
+  async request(path2, options = {}) {
+    const fetchFn = this.fetchImpl ?? globalThis.fetch;
+    if (!fetchFn) {
+      throw new ConfigError(
+        "fetch is not available; provide a fetch implementation"
+      );
     }
-    const form = new URLSearchParams();
-    form.set("grant_type", "urn:ietf:params:oauth:grant-type:device_code");
-    form.set("device_code", deviceCode);
-    form.set("client_id", clientId);
-    const payload = await postOAuthForm(tokenEndpoint, form, {
-      fetch: req.fetch,
-      signal: req.signal,
-      allowErrorPayload: true
+    const method = options.method || "GET";
+    const url = buildUrl(this.baseUrl, path2);
+    const metrics = mergeMetrics(this.metrics, options.metrics);
+    const trace = mergeTrace(this.trace, options.trace);
+    const context = {
+      method,
+      path: path2,
+      ...options.context || {}
+    };
+    trace?.requestStart?.(context);
+    const start = metrics?.httpRequest || trace?.requestFinish ? Date.now() : 0;
+    const headers = new Headers({
+      ...this.defaultHeaders,
+      ...options.headers || {}
     });
-    const err = String(payload.error || "").trim();
-    if (err) {
-      switch (err) {
-        case "authorization_pending":
-          await sleep(intervalMs, req.signal);
-          continue;
-        case "slow_down":
-          intervalMs += 5e3;
-          await sleep(intervalMs, req.signal);
-          continue;
-        case "expired_token":
-        case "access_denied":
-        case "invalid_grant":
-          throw new TransportError(`oauth device flow failed: ${err}`, {
-            kind: "request",
-            cause: payload
+    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
           });
-        default:
-          throw new TransportError(`oauth device flow error: ${err}`, {
-            kind: "request",
-            cause: payload
+          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 accessToken = String(payload.access_token || "").trim() || void 0;
-    const idToken = String(payload.id_token || "").trim() || void 0;
-    const refreshToken = String(payload.refresh_token || "").trim() || void 0;
-    const tokenType = String(payload.token_type || "").trim() || void 0;
-    const scope = String(payload.scope || "").trim() || void 0;
-    const expiresIn = payload.expires_in !== void 0 ? Number(payload.expires_in) : void 0;
-    const expiresAt = typeof expiresIn === "number" && Number.isFinite(expiresIn) && expiresIn > 0 ? new Date(Date.now() + expiresIn * 1e3) : void 0;
-    if (!accessToken && !idToken) {
-      throw new TransportError("oauth device flow returned an invalid token response", {
-        kind: "request",
-        cause: payload
+    throw lastError instanceof Error ? lastError : new TransportError("request failed", {
+      kind: "other",
+      retries: buildRetryMetadata(attempts, lastStatus)
+    });
+  }
+  async json(path2, options = {}) {
+    const response = await this.request(path2, {
+      ...options,
+      raw: true,
+      accept: options.accept || "application/json"
+    });
+    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
       });
     }
-    return { accessToken, idToken, refreshToken, tokenType, scope, expiresAt };
   }
+};
+function buildUrl(baseUrl, path2) {
+  if (/^https?:\/\//i.test(path2)) {
+    return path2;
+  }
+  if (!path2.startsWith("/")) {
+    path2 = `/${path2}`;
+  }
+  return `${baseUrl}${path2}`;
 }
-async function runOAuthDeviceFlowForIDToken(cfg) {
-  const auth = await startOAuthDeviceAuthorization({
-    deviceAuthorizationEndpoint: cfg.deviceAuthorizationEndpoint,
-    clientId: cfg.clientId,
-    scope: cfg.scope,
-    audience: cfg.audience,
-    fetch: cfg.fetch,
-    signal: cfg.signal
-  });
-  await cfg.onUserCode(auth);
-  const token = await pollOAuthDeviceToken({
-    tokenEndpoint: cfg.tokenEndpoint,
-    clientId: cfg.clientId,
-    deviceCode: auth.deviceCode,
-    intervalSeconds: auth.intervalSeconds,
-    deadline: auth.expiresAt,
-    fetch: cfg.fetch,
-    signal: cfg.signal
-  });
-  if (!token.idToken) {
-    throw new TransportError("oauth device flow did not return an id_token", {
-      kind: "request",
-      cause: token
-    });
+function normalizeBaseUrl(value) {
+  const trimmed = value.trim();
+  if (trimmed.endsWith("/")) {
+    return trimmed.slice(0, -1);
   }
-  return token.idToken;
+  return trimmed;
 }
-async function postOAuthForm(url, form, opts) {
-  const fetchFn = opts.fetch ?? globalThis.fetch;
-  if (!fetchFn) {
-    throw new ConfigError("fetch is not available; provide a fetch implementation");
-  }
-  let resp;
-  try {
-    resp = await fetchFn(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: form.toString(),
-      signal: opts.signal
-    });
-  } catch (cause) {
-    throw new TransportError("oauth request failed", { kind: "request", cause });
-  }
-  let json;
-  try {
-    json = await resp.json();
-  } catch (cause) {
-    throw new TransportError("oauth response was not valid JSON", { kind: "request", cause });
-  }
-  if (!resp.ok && !opts.allowErrorPayload) {
-    throw new TransportError(`oauth request failed (${resp.status})`, {
-      kind: "request",
-      cause: json
-    });
-  }
-  return json || {};
+function isValidHttpUrl(value) {
+  return /^https?:\/\//i.test(value);
 }
-async function sleep(ms, signal) {
-  if (!ms || ms <= 0) {
-    return;
-  }
-  if (!signal) {
-    await new Promise((resolve) => setTimeout(resolve, ms));
-    return;
+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;
   }
-  if (signal.aborted) {
-    throw new TransportError("oauth device flow aborted", { kind: "request" });
+  if (status >= 500 && status < 600) {
+    return method !== "POST" || retryPost;
   }
-  await new Promise((resolve, reject) => {
-    const onAbort = () => {
-      signal.removeEventListener("abort", onAbort);
-      reject(new TransportError("oauth device flow aborted", { kind: "request" }));
-    };
-    signal.addEventListener("abort", onAbort);
-    setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-  });
-}
-
-// src/workflow_builder.ts
-function transformJSONValue(from, pointer) {
-  return pointer ? { from, pointer } : { from };
+  return false;
 }
-function transformJSONObject(object) {
-  return { object };
+function isRetryableError(err, kind) {
+  if (!err) return false;
+  if (kind === "timeout" || kind === "connect") return true;
+  return err instanceof DOMException || err instanceof TypeError;
 }
-function transformJSONMerge(merge) {
-  return { merge: merge.slice() };
+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((resolve2) => setTimeout(resolve2, delay));
 }
-function wireRequest(req) {
-  const raw = req;
-  if (raw && typeof raw === "object") {
-    if ("input" in raw) {
-      return req;
-    }
-    if ("body" in raw) {
-      return raw.body ?? {};
+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;
     }
+    src.addEventListener(
+      "abort",
+      () => controller.abort(src.reason),
+      { once: true }
+    );
   }
-  return asInternal(req).body;
+  return controller.signal;
 }
-var WorkflowBuilderV0 = class _WorkflowBuilderV0 {
-  constructor(state = { nodes: [], edges: [], outputs: [] }) {
-    this.state = state;
+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;
+    }
   }
-  static new() {
-    return new _WorkflowBuilderV0();
+  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";
   }
-  with(patch) {
-    return new _WorkflowBuilderV0({
-      ...this.state,
-      ...patch
+  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
     });
   }
-  name(name) {
-    return this.with({ name: name.trim() || void 0 });
-  }
-  execution(execution) {
-    return this.with({ execution });
-  }
-  node(node) {
-    return this.with({ nodes: [...this.state.nodes, node] });
+  trace?.requestFinish?.({
+    context: info.context,
+    status: info.status,
+    error: info.error,
+    retries,
+    latencyMs
+  });
+}
+function withRequestId(context, headers) {
+  const requestId = headers.get("X-ModelRelay-Request-Id") || headers.get("X-Request-Id") || context.requestId;
+  if (!requestId) return context;
+  return { ...context, requestId };
+}
+
+// src/customer_scoped.ts
+function normalizeCustomerId(customerId) {
+  const trimmed = customerId?.trim?.() ? customerId.trim() : "";
+  if (!trimmed) {
+    throw new ConfigError("customerId is required");
   }
-  llmResponses(id, request, options = {}) {
-    const input = {
-      request: wireRequest(request),
-      ...options.stream === void 0 ? {} : { stream: options.stream },
-      ...options.toolExecution === void 0 ? {} : { tool_execution: { mode: options.toolExecution } },
-      ...options.toolLimits === void 0 ? {} : { tool_limits: { ...options.toolLimits } },
-      ...options.bindings === void 0 ? {} : { bindings: options.bindings.slice() }
-    };
-    return this.node({
-      id,
-      type: WorkflowNodeTypes.LLMResponses,
-      input
+  return trimmed;
+}
+function mergeCustomerOptions(customerId, options = {}) {
+  if (options.customerId && options.customerId !== customerId) {
+    throw new ConfigError("customerId mismatch", {
+      expected: customerId,
+      received: options.customerId
     });
   }
-  joinAll(id) {
-    return this.node({ id, type: WorkflowNodeTypes.JoinAll });
-  }
-  transformJSON(id, input) {
-    return this.node({ id, type: WorkflowNodeTypes.TransformJSON, input });
+  return { ...options, customerId };
+}
+var CustomerResponsesClient = class {
+  constructor(base, customerId) {
+    this.customerId = normalizeCustomerId(customerId);
+    this.base = base;
   }
-  edge(from, to) {
-    return this.with({ edges: [...this.state.edges, { from, to }] });
+  get id() {
+    return this.customerId;
   }
-  output(name, from, pointer) {
-    return this.with({
-      outputs: [
-        ...this.state.outputs,
-        { name, from, ...pointer ? { pointer } : {} }
-      ]
-    });
+  new() {
+    return this.base.new().customerId(this.customerId);
   }
-  build() {
-    const edges = this.state.edges.slice().sort((a, b) => {
-      const af = String(a.from);
-      const bf = String(b.from);
-      if (af < bf) return -1;
-      if (af > bf) return 1;
-      const at = String(a.to);
-      const bt = String(b.to);
-      if (at < bt) return -1;
-      if (at > bt) return 1;
-      return 0;
-    });
-    const outputs = this.state.outputs.slice().sort((a, b) => {
-      const an = String(a.name);
-      const bn = String(b.name);
-      if (an < bn) return -1;
-      if (an > bn) return 1;
-      const af = String(a.from);
-      const bf = String(b.from);
-      if (af < bf) return -1;
-      if (af > bf) return 1;
-      const ap = a.pointer ?? "";
-      const bp = b.pointer ?? "";
-      if (ap < bp) return -1;
-      if (ap > bp) return 1;
-      return 0;
+  ensureRequestCustomer(request) {
+    const req = asInternal(request);
+    const reqCustomer = req.options.customerId;
+    if (reqCustomer && reqCustomer !== this.customerId) {
+      throw new ConfigError("customerId mismatch", {
+        expected: this.customerId,
+        received: reqCustomer
+      });
+    }
+  }
+  async create(request, options = {}) {
+    this.ensureRequestCustomer(request);
+    return this.base.create(request, mergeCustomerOptions(this.customerId, options));
+  }
+  async stream(request, options = {}) {
+    this.ensureRequestCustomer(request);
+    return this.base.stream(request, mergeCustomerOptions(this.customerId, options));
+  }
+  async streamJSON(request, options = {}) {
+    this.ensureRequestCustomer(request);
+    return this.base.streamJSON(
+      request,
+      mergeCustomerOptions(this.customerId, options)
+    );
+  }
+  async text(system, user, options = {}) {
+    return this.base.textForCustomer(
+      this.customerId,
+      system,
+      user,
+      mergeCustomerOptions(this.customerId, options)
+    );
+  }
+  async streamTextDeltas(system, user, options = {}) {
+    return this.base.streamTextDeltasForCustomer(
+      this.customerId,
+      system,
+      user,
+      mergeCustomerOptions(this.customerId, options)
+    );
+  }
+};
+var CustomerScopedModelRelay = class {
+  constructor(responses, customerId, baseUrl) {
+    const normalized = normalizeCustomerId(customerId);
+    this.responses = new CustomerResponsesClient(responses, normalized);
+    this.customerId = normalized;
+    this.baseUrl = baseUrl;
+  }
+};
+
+// src/token_providers.ts
+function isReusable(token) {
+  if (!token.token) {
+    return false;
+  }
+  return token.expiresAt.getTime() - Date.now() > 6e4;
+}
+var FrontendTokenProvider = class {
+  constructor(cfg) {
+    const publishableKey = parsePublishableKey(cfg.publishableKey);
+    const http = new HTTPClient({
+      baseUrl: cfg.baseUrl || DEFAULT_BASE_URL,
+      fetchImpl: cfg.fetch,
+      clientHeader: cfg.clientHeader || DEFAULT_CLIENT_HEADER,
+      apiKey: publishableKey
     });
-    return {
-      kind: WorkflowKinds.WorkflowV0,
-      ...this.state.name ? { name: this.state.name } : {},
-      ...this.state.execution ? { execution: this.state.execution } : {},
-      nodes: this.state.nodes.slice(),
-      ...edges.length ? { edges } : {},
-      outputs
+    this.publishableKey = publishableKey;
+    this.customer = cfg.customer;
+    this.auth = new AuthClient(http, { apiKey: publishableKey, customer: cfg.customer });
+  }
+  async getToken() {
+    if (!this.customer?.provider || !this.customer?.subject) {
+      throw new ConfigError("customer.provider and customer.subject are required");
+    }
+    const reqBase = {
+      publishableKey: this.publishableKey,
+      identityProvider: this.customer.provider,
+      identitySubject: this.customer.subject,
+      deviceId: this.customer.deviceId,
+      ttlSeconds: this.customer.ttlSeconds
     };
+    let token;
+    if (this.customer.email) {
+      const req = {
+        ...reqBase,
+        email: this.customer.email
+      };
+      token = await this.auth.frontendTokenAutoProvision(req);
+    } else {
+      const req = reqBase;
+      token = await this.auth.frontendToken(req);
+    }
+    if (!token.token) {
+      throw new ConfigError("frontend token exchange returned an empty token");
+    }
+    return token.token;
+  }
+};
+var CustomerTokenProvider = class {
+  constructor(cfg) {
+    const key = parseSecretKey(cfg.secretKey);
+    const http = new HTTPClient({
+      baseUrl: cfg.baseUrl || DEFAULT_BASE_URL,
+      fetchImpl: cfg.fetch,
+      clientHeader: cfg.clientHeader || DEFAULT_CLIENT_HEADER,
+      apiKey: key
+    });
+    this.auth = new AuthClient(http, { apiKey: key });
+    this.req = cfg.request;
+  }
+  async getToken() {
+    if (this.cached && isReusable(this.cached)) {
+      return this.cached.token;
+    }
+    const token = await this.auth.customerToken(this.req);
+    this.cached = token;
+    return token.token;
+  }
+};
+var OIDCExchangeTokenProvider = class {
+  constructor(cfg) {
+    const apiKey = parseApiKey(cfg.apiKey);
+    const http = new HTTPClient({
+      baseUrl: cfg.baseUrl || DEFAULT_BASE_URL,
+      fetchImpl: cfg.fetch,
+      clientHeader: cfg.clientHeader || DEFAULT_CLIENT_HEADER,
+      apiKey
+    });
+    this.auth = new AuthClient(http, { apiKey });
+    this.idTokenProvider = cfg.idTokenProvider;
+    this.request = { idToken: "", projectId: cfg.projectId };
+  }
+  async getToken() {
+    if (this.cached && isReusable(this.cached)) {
+      return this.cached.token;
+    }
+    const idToken = (await this.idTokenProvider())?.trim();
+    if (!idToken) {
+      throw new ConfigError("idTokenProvider returned an empty id_token");
+    }
+    const token = await this.auth.oidcExchange({ ...this.request, idToken });
+    this.cached = token;
+    return token.token;
   }
 };
-function workflowV0() {
-  return WorkflowBuilderV0.new();
-}
 
-// src/workflow_v0.schema.json
-var workflow_v0_schema_default = {
-  $id: "https://modelrelay.ai/schemas/workflow_v0.schema.json",
-  $schema: "http://json-schema.org/draft-07/schema#",
-  additionalProperties: false,
-  definitions: {
-    edge: {
-      additionalProperties: false,
-      properties: {
-        from: {
-          minLength: 1,
-          type: "string"
-        },
-        to: {
-          minLength: 1,
-          type: "string"
-        }
-      },
-      required: [
-        "from",
-        "to"
-      ],
-      type: "object"
-    },
-    llmResponsesBinding: {
-      additionalProperties: false,
-      properties: {
-        encoding: {
-          enum: [
-            "json",
-            "json_string"
-          ],
-          type: "string"
-        },
-        from: {
-          minLength: 1,
-          type: "string"
-        },
-        pointer: {
-          pattern: "^(/.*)?$",
-          type: "string"
-        },
-        to: {
-          pattern: "^/.*$",
-          type: "string"
-        }
-      },
-      required: [
-        "from",
-        "to"
-      ],
-      type: "object"
-    },
-    node: {
-      additionalProperties: false,
-      oneOf: [
-        {
-          allOf: [
-            {
-              properties: {
-                input: {
-                  properties: {
-                    bindings: {
-                      items: {
-                        $ref: "#/definitions/llmResponsesBinding"
-                      },
-                      type: "array"
-                    },
-                    request: {
-                      type: "object"
-                    },
-                    stream: {
-                      type: "boolean"
-                    },
-                    tool_execution: {
-                      additionalProperties: false,
-                      properties: {
-                        mode: {
-                          default: "server",
-                          enum: [
-                            "server",
+// src/device_flow.ts
+async function startOAuthDeviceAuthorization(req) {
+  const deviceAuthorizationEndpoint = req.deviceAuthorizationEndpoint?.trim();
+  if (!deviceAuthorizationEndpoint) {
+    throw new ConfigError("deviceAuthorizationEndpoint is required");
+  }
+  const clientId = req.clientId?.trim();
+  if (!clientId) {
+    throw new ConfigError("clientId is required");
+  }
+  const form = new URLSearchParams();
+  form.set("client_id", clientId);
+  if (req.scope?.trim()) {
+    form.set("scope", req.scope.trim());
+  }
+  if (req.audience?.trim()) {
+    form.set("audience", req.audience.trim());
+  }
+  const payload = await postOAuthForm(deviceAuthorizationEndpoint, form, {
+    fetch: req.fetch,
+    signal: req.signal
+  });
+  const deviceCode = String(payload.device_code || "").trim();
+  const userCode = String(payload.user_code || "").trim();
+  const verificationUri = String(payload.verification_uri || payload.verification_uri_complete || "").trim();
+  const verificationUriComplete = String(payload.verification_uri_complete || "").trim() || void 0;
+  const expiresIn = Number(payload.expires_in || 0);
+  const intervalSeconds = Math.max(1, Number(payload.interval || 5));
+  if (!deviceCode || !userCode || !verificationUri || !expiresIn) {
+    throw new TransportError("oauth device authorization returned an invalid response", {
+      kind: "request",
+      cause: payload
+    });
+  }
+  return {
+    deviceCode,
+    userCode,
+    verificationUri,
+    verificationUriComplete,
+    expiresAt: new Date(Date.now() + expiresIn * 1e3),
+    intervalSeconds
+  };
+}
+async function pollOAuthDeviceToken(req) {
+  const tokenEndpoint = req.tokenEndpoint?.trim();
+  if (!tokenEndpoint) {
+    throw new ConfigError("tokenEndpoint is required");
+  }
+  const clientId = req.clientId?.trim();
+  if (!clientId) {
+    throw new ConfigError("clientId is required");
+  }
+  const deviceCode = req.deviceCode?.trim();
+  if (!deviceCode) {
+    throw new ConfigError("deviceCode is required");
+  }
+  const deadline = req.deadline ?? new Date(Date.now() + 10 * 60 * 1e3);
+  let intervalMs = Math.max(1, req.intervalSeconds ?? 5) * 1e3;
+  while (true) {
+    if (Date.now() >= deadline.getTime()) {
+      throw new TransportError("oauth device flow timed out", { kind: "timeout" });
+    }
+    const form = new URLSearchParams();
+    form.set("grant_type", "urn:ietf:params:oauth:grant-type:device_code");
+    form.set("device_code", deviceCode);
+    form.set("client_id", clientId);
+    const payload = await postOAuthForm(tokenEndpoint, form, {
+      fetch: req.fetch,
+      signal: req.signal,
+      allowErrorPayload: true
+    });
+    const err = String(payload.error || "").trim();
+    if (err) {
+      switch (err) {
+        case "authorization_pending":
+          await sleep(intervalMs, req.signal);
+          continue;
+        case "slow_down":
+          intervalMs += 5e3;
+          await sleep(intervalMs, req.signal);
+          continue;
+        case "expired_token":
+        case "access_denied":
+        case "invalid_grant":
+          throw new TransportError(`oauth device flow failed: ${err}`, {
+            kind: "request",
+            cause: payload
+          });
+        default:
+          throw new TransportError(`oauth device flow error: ${err}`, {
+            kind: "request",
+            cause: payload
+          });
+      }
+    }
+    const accessToken = String(payload.access_token || "").trim() || void 0;
+    const idToken = String(payload.id_token || "").trim() || void 0;
+    const refreshToken = String(payload.refresh_token || "").trim() || void 0;
+    const tokenType = String(payload.token_type || "").trim() || void 0;
+    const scope = String(payload.scope || "").trim() || void 0;
+    const expiresIn = payload.expires_in !== void 0 ? Number(payload.expires_in) : void 0;
+    const expiresAt = typeof expiresIn === "number" && Number.isFinite(expiresIn) && expiresIn > 0 ? new Date(Date.now() + expiresIn * 1e3) : void 0;
+    if (!accessToken && !idToken) {
+      throw new TransportError("oauth device flow returned an invalid token response", {
+        kind: "request",
+        cause: payload
+      });
+    }
+    return { accessToken, idToken, refreshToken, tokenType, scope, expiresAt };
+  }
+}
+async function runOAuthDeviceFlowForIDToken(cfg) {
+  const auth = await startOAuthDeviceAuthorization({
+    deviceAuthorizationEndpoint: cfg.deviceAuthorizationEndpoint,
+    clientId: cfg.clientId,
+    scope: cfg.scope,
+    audience: cfg.audience,
+    fetch: cfg.fetch,
+    signal: cfg.signal
+  });
+  await cfg.onUserCode(auth);
+  const token = await pollOAuthDeviceToken({
+    tokenEndpoint: cfg.tokenEndpoint,
+    clientId: cfg.clientId,
+    deviceCode: auth.deviceCode,
+    intervalSeconds: auth.intervalSeconds,
+    deadline: auth.expiresAt,
+    fetch: cfg.fetch,
+    signal: cfg.signal
+  });
+  if (!token.idToken) {
+    throw new TransportError("oauth device flow did not return an id_token", {
+      kind: "request",
+      cause: token
+    });
+  }
+  return token.idToken;
+}
+async function postOAuthForm(url, form, opts) {
+  const fetchFn = opts.fetch ?? globalThis.fetch;
+  if (!fetchFn) {
+    throw new ConfigError("fetch is not available; provide a fetch implementation");
+  }
+  let resp;
+  try {
+    resp = await fetchFn(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: form.toString(),
+      signal: opts.signal
+    });
+  } catch (cause) {
+    throw new TransportError("oauth request failed", { kind: "request", cause });
+  }
+  let json;
+  try {
+    json = await resp.json();
+  } catch (cause) {
+    throw new TransportError("oauth response was not valid JSON", { kind: "request", cause });
+  }
+  if (!resp.ok && !opts.allowErrorPayload) {
+    throw new TransportError(`oauth request failed (${resp.status})`, {
+      kind: "request",
+      cause: json
+    });
+  }
+  return json || {};
+}
+async function sleep(ms, signal) {
+  if (!ms || ms <= 0) {
+    return;
+  }
+  if (!signal) {
+    await new Promise((resolve2) => setTimeout(resolve2, ms));
+    return;
+  }
+  if (signal.aborted) {
+    throw new TransportError("oauth device flow aborted", { kind: "request" });
+  }
+  await new Promise((resolve2, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(new TransportError("oauth device flow aborted", { kind: "request" }));
+    };
+    signal.addEventListener("abort", onAbort);
+    setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+  });
+}
+
+// src/workflow_builder.ts
+function transformJSONValue(from, pointer) {
+  return pointer ? { from, pointer } : { from };
+}
+function transformJSONObject(object) {
+  return { object };
+}
+function transformJSONMerge(merge) {
+  return { merge: merge.slice() };
+}
+function wireRequest(req) {
+  const raw = req;
+  if (raw && typeof raw === "object") {
+    if ("input" in raw) {
+      return req;
+    }
+    if ("body" in raw) {
+      return raw.body ?? {};
+    }
+  }
+  return asInternal(req).body;
+}
+var WorkflowBuilderV0 = class _WorkflowBuilderV0 {
+  constructor(state = { nodes: [], edges: [], outputs: [] }) {
+    this.state = state;
+  }
+  static new() {
+    return new _WorkflowBuilderV0();
+  }
+  with(patch) {
+    return new _WorkflowBuilderV0({
+      ...this.state,
+      ...patch
+    });
+  }
+  name(name) {
+    return this.with({ name: name.trim() || void 0 });
+  }
+  execution(execution) {
+    return this.with({ execution });
+  }
+  node(node) {
+    return this.with({ nodes: [...this.state.nodes, node] });
+  }
+  llmResponses(id, request, options = {}) {
+    const input = {
+      request: wireRequest(request),
+      ...options.stream === void 0 ? {} : { stream: options.stream },
+      ...options.toolExecution === void 0 ? {} : { tool_execution: { mode: options.toolExecution } },
+      ...options.toolLimits === void 0 ? {} : { tool_limits: { ...options.toolLimits } },
+      ...options.bindings === void 0 ? {} : { bindings: options.bindings.slice() }
+    };
+    return this.node({
+      id,
+      type: WorkflowNodeTypes.LLMResponses,
+      input
+    });
+  }
+  joinAll(id) {
+    return this.node({ id, type: WorkflowNodeTypes.JoinAll });
+  }
+  transformJSON(id, input) {
+    return this.node({ id, type: WorkflowNodeTypes.TransformJSON, input });
+  }
+  edge(from, to) {
+    return this.with({ edges: [...this.state.edges, { from, to }] });
+  }
+  output(name, from, pointer) {
+    return this.with({
+      outputs: [
+        ...this.state.outputs,
+        { name, from, ...pointer ? { pointer } : {} }
+      ]
+    });
+  }
+  build() {
+    const edges = this.state.edges.slice().sort((a, b) => {
+      const af = String(a.from);
+      const bf = String(b.from);
+      if (af < bf) return -1;
+      if (af > bf) return 1;
+      const at = String(a.to);
+      const bt = String(b.to);
+      if (at < bt) return -1;
+      if (at > bt) return 1;
+      return 0;
+    });
+    const outputs = this.state.outputs.slice().sort((a, b) => {
+      const an = String(a.name);
+      const bn = String(b.name);
+      if (an < bn) return -1;
+      if (an > bn) return 1;
+      const af = String(a.from);
+      const bf = String(b.from);
+      if (af < bf) return -1;
+      if (af > bf) return 1;
+      const ap = a.pointer ?? "";
+      const bp = b.pointer ?? "";
+      if (ap < bp) return -1;
+      if (ap > bp) return 1;
+      return 0;
+    });
+    return {
+      kind: WorkflowKinds.WorkflowV0,
+      ...this.state.name ? { name: this.state.name } : {},
+      ...this.state.execution ? { execution: this.state.execution } : {},
+      nodes: this.state.nodes.slice(),
+      ...edges.length ? { edges } : {},
+      outputs
+    };
+  }
+};
+function workflowV0() {
+  return WorkflowBuilderV0.new();
+}
+
+// src/workflow_v0.schema.json
+var workflow_v0_schema_default = {
+  $id: "https://modelrelay.ai/schemas/workflow_v0.schema.json",
+  $schema: "http://json-schema.org/draft-07/schema#",
+  additionalProperties: false,
+  definitions: {
+    edge: {
+      additionalProperties: false,
+      properties: {
+        from: {
+          minLength: 1,
+          type: "string"
+        },
+        to: {
+          minLength: 1,
+          type: "string"
+        }
+      },
+      required: [
+        "from",
+        "to"
+      ],
+      type: "object"
+    },
+    llmResponsesBinding: {
+      additionalProperties: false,
+      properties: {
+        encoding: {
+          enum: [
+            "json",
+            "json_string"
+          ],
+          type: "string"
+        },
+        from: {
+          minLength: 1,
+          type: "string"
+        },
+        pointer: {
+          pattern: "^(/.*)?$",
+          type: "string"
+        },
+        to: {
+          pattern: "^/.*$",
+          type: "string"
+        }
+      },
+      required: [
+        "from",
+        "to"
+      ],
+      type: "object"
+    },
+    node: {
+      additionalProperties: false,
+      oneOf: [
+        {
+          allOf: [
+            {
+              properties: {
+                input: {
+                  properties: {
+                    bindings: {
+                      items: {
+                        $ref: "#/definitions/llmResponsesBinding"
+                      },
+                      type: "array"
+                    },
+                    request: {
+                      type: "object"
+                    },
+                    stream: {
+                      type: "boolean"
+                    },
+                    tool_execution: {
+                      additionalProperties: false,
+                      properties: {
+                        mode: {
+                          default: "server",
+                          enum: [
+                            "server",
                             "client"
                           ],
                           type: "string"
@@ -8924,182 +10013,1499 @@ var workflow_v0_schema_default = {
               const: "join.all"
             }
           }
-        },
-        {
-          allOf: [
-            {
-              properties: {
-                input: {
-                  additionalProperties: false,
-                  oneOf: [
-                    {
-                      not: {
-                        required: [
-                          "merge"
-                        ]
-                      },
-                      required: [
-                        "object"
-                      ]
-                    },
-                    {
-                      not: {
-                        required: [
-                          "object"
-                        ]
-                      },
-                      required: [
-                        "merge"
-                      ]
-                    }
-                  ],
-                  properties: {
-                    merge: {
-                      items: {
-                        $ref: "#/definitions/transformValue"
-                      },
-                      minItems: 1,
-                      type: "array"
-                    },
-                    object: {
-                      additionalProperties: {
-                        $ref: "#/definitions/transformValue"
-                      },
-                      minProperties: 1,
-                      type: "object"
-                    }
-                  },
-                  type: "object"
-                }
+        },
+        {
+          allOf: [
+            {
+              properties: {
+                input: {
+                  additionalProperties: false,
+                  oneOf: [
+                    {
+                      not: {
+                        required: [
+                          "merge"
+                        ]
+                      },
+                      required: [
+                        "object"
+                      ]
+                    },
+                    {
+                      not: {
+                        required: [
+                          "object"
+                        ]
+                      },
+                      required: [
+                        "merge"
+                      ]
+                    }
+                  ],
+                  properties: {
+                    merge: {
+                      items: {
+                        $ref: "#/definitions/transformValue"
+                      },
+                      minItems: 1,
+                      type: "array"
+                    },
+                    object: {
+                      additionalProperties: {
+                        $ref: "#/definitions/transformValue"
+                      },
+                      minProperties: 1,
+                      type: "object"
+                    }
+                  },
+                  type: "object"
+                }
+              }
+            }
+          ],
+          properties: {
+            type: {
+              const: "transform.json"
+            }
+          },
+          required: [
+            "input"
+          ]
+        }
+      ],
+      properties: {
+        id: {
+          minLength: 1,
+          type: "string"
+        },
+        input: {},
+        type: {
+          enum: [
+            "llm.responses",
+            "join.all",
+            "transform.json"
+          ],
+          type: "string"
+        }
+      },
+      required: [
+        "id",
+        "type"
+      ],
+      type: "object"
+    },
+    output: {
+      additionalProperties: false,
+      properties: {
+        from: {
+          minLength: 1,
+          type: "string"
+        },
+        name: {
+          minLength: 1,
+          type: "string"
+        },
+        pointer: {
+          pattern: "^(/.*)?$",
+          type: "string"
+        }
+      },
+      required: [
+        "name",
+        "from"
+      ],
+      type: "object"
+    },
+    transformValue: {
+      additionalProperties: false,
+      properties: {
+        from: {
+          minLength: 1,
+          type: "string"
+        },
+        pointer: {
+          pattern: "^(/.*)?$",
+          type: "string"
+        }
+      },
+      required: [
+        "from"
+      ],
+      type: "object"
+    }
+  },
+  properties: {
+    edges: {
+      items: {
+        $ref: "#/definitions/edge"
+      },
+      type: "array"
+    },
+    execution: {
+      additionalProperties: false,
+      properties: {
+        max_parallelism: {
+          minimum: 1,
+          type: "integer"
+        },
+        node_timeout_ms: {
+          minimum: 1,
+          type: "integer"
+        },
+        run_timeout_ms: {
+          minimum: 1,
+          type: "integer"
+        }
+      },
+      type: "object"
+    },
+    kind: {
+      const: "workflow.v0",
+      type: "string"
+    },
+    name: {
+      type: "string"
+    },
+    nodes: {
+      items: {
+        $ref: "#/definitions/node"
+      },
+      minItems: 1,
+      type: "array"
+    },
+    outputs: {
+      items: {
+        $ref: "#/definitions/output"
+      },
+      minItems: 1,
+      type: "array"
+    }
+  },
+  required: [
+    "kind",
+    "nodes",
+    "outputs"
+  ],
+  title: "ModelRelay workflow.v0",
+  type: "object"
+};
+
+// src/tools_local_fs.ts
+import { promises as fs } from "fs";
+import * as path from "path";
+import { spawn } from "child_process";
+var ToolNames = {
+  FS_READ_FILE: "fs.read_file",
+  FS_LIST_FILES: "fs.list_files",
+  FS_SEARCH: "fs.search"
+};
+var FSDefaults = {
+  MAX_READ_BYTES: 64e3,
+  HARD_MAX_READ_BYTES: 1e6,
+  MAX_LIST_ENTRIES: 2e3,
+  HARD_MAX_LIST_ENTRIES: 2e4,
+  MAX_SEARCH_MATCHES: 100,
+  HARD_MAX_SEARCH_MATCHES: 2e3,
+  SEARCH_TIMEOUT_MS: 5e3,
+  MAX_SEARCH_BYTES_PER_FILE: 1e6
+};
+var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  "vendor",
+  "dist",
+  "build",
+  ".next",
+  "target",
+  ".idea",
+  ".vscode",
+  "__pycache__",
+  ".pytest_cache",
+  "coverage"
+]);
+var LocalFSToolPack = class {
+  constructor(options) {
+    this.rgPath = null;
+    this.rgChecked = false;
+    const root = options.root?.trim();
+    if (!root) {
+      throw new Error("LocalFSToolPack: root directory required");
+    }
+    this.rootAbs = path.resolve(root);
+    this.cfg = {
+      ignoreDirs: options.ignoreDirs ?? new Set(DEFAULT_IGNORE_DIRS),
+      maxReadBytes: options.maxReadBytes ?? FSDefaults.MAX_READ_BYTES,
+      hardMaxReadBytes: options.hardMaxReadBytes ?? FSDefaults.HARD_MAX_READ_BYTES,
+      maxListEntries: options.maxListEntries ?? FSDefaults.MAX_LIST_ENTRIES,
+      hardMaxListEntries: options.hardMaxListEntries ?? FSDefaults.HARD_MAX_LIST_ENTRIES,
+      maxSearchMatches: options.maxSearchMatches ?? FSDefaults.MAX_SEARCH_MATCHES,
+      hardMaxSearchMatches: options.hardMaxSearchMatches ?? FSDefaults.HARD_MAX_SEARCH_MATCHES,
+      searchTimeoutMs: options.searchTimeoutMs ?? FSDefaults.SEARCH_TIMEOUT_MS,
+      maxSearchBytesPerFile: options.maxSearchBytesPerFile ?? FSDefaults.MAX_SEARCH_BYTES_PER_FILE
+    };
+  }
+  /**
+   * Returns the tool definitions for LLM requests.
+   * Use these when constructing the tools array for /responses requests.
+   */
+  getToolDefinitions() {
+    return [
+      {
+        type: "function",
+        function: {
+          name: ToolNames.FS_READ_FILE,
+          description: "Read the contents of a file. Returns the file contents as UTF-8 text.",
+          parameters: {
+            type: "object",
+            properties: {
+              path: {
+                type: "string",
+                description: "Workspace-relative path to the file (e.g., 'src/index.ts')"
+              },
+              max_bytes: {
+                type: "integer",
+                description: `Maximum bytes to read. Default: ${this.cfg.maxReadBytes}, max: ${this.cfg.hardMaxReadBytes}`
+              }
+            },
+            required: ["path"]
+          }
+        }
+      },
+      {
+        type: "function",
+        function: {
+          name: ToolNames.FS_LIST_FILES,
+          description: "List files recursively in a directory. Returns newline-separated workspace-relative paths.",
+          parameters: {
+            type: "object",
+            properties: {
+              path: {
+                type: "string",
+                description: "Workspace-relative directory path. Default: '.' (workspace root)"
+              },
+              max_entries: {
+                type: "integer",
+                description: `Maximum files to list. Default: ${this.cfg.maxListEntries}, max: ${this.cfg.hardMaxListEntries}`
               }
             }
-          ],
-          properties: {
-            type: {
-              const: "transform.json"
-            }
-          },
-          required: [
-            "input"
-          ]
+          }
         }
-      ],
-      properties: {
-        id: {
-          minLength: 1,
-          type: "string"
-        },
-        input: {},
-        type: {
-          enum: [
-            "llm.responses",
-            "join.all",
-            "transform.json"
-          ],
-          type: "string"
+      },
+      {
+        type: "function",
+        function: {
+          name: ToolNames.FS_SEARCH,
+          description: "Search for text matching a regex pattern. Returns matches as 'path:line:content' format.",
+          parameters: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: "Regex pattern to search for"
+              },
+              path: {
+                type: "string",
+                description: "Workspace-relative directory to search. Default: '.' (workspace root)"
+              },
+              max_matches: {
+                type: "integer",
+                description: `Maximum matches to return. Default: ${this.cfg.maxSearchMatches}, max: ${this.cfg.hardMaxSearchMatches}`
+              }
+            },
+            required: ["query"]
+          }
+        }
+      }
+    ];
+  }
+  /**
+   * Registers handlers into an existing ToolRegistry.
+   * @param registry - The registry to register into
+   * @returns The registry for chaining
+   */
+  registerInto(registry) {
+    registry.register(ToolNames.FS_READ_FILE, this.readFile.bind(this));
+    registry.register(ToolNames.FS_LIST_FILES, this.listFiles.bind(this));
+    registry.register(ToolNames.FS_SEARCH, this.search.bind(this));
+    return registry;
+  }
+  /**
+   * Creates a new ToolRegistry with fs.* tools pre-registered.
+   */
+  toRegistry() {
+    return this.registerInto(new ToolRegistry());
+  }
+  // ========================================================================
+  // Tool Handlers
+  // ========================================================================
+  async readFile(_args, call) {
+    const args = this.parseArgs(call, ["path"]);
+    const func = call.function;
+    const relPath = this.requireString(args, "path", call);
+    const requestedMax = this.optionalPositiveInt(args, "max_bytes", call);
+    let maxBytes = this.cfg.maxReadBytes;
+    if (requestedMax !== void 0) {
+      if (requestedMax > this.cfg.hardMaxReadBytes) {
+        throw new ToolArgumentError({
+          message: `max_bytes exceeds hard cap (${this.cfg.hardMaxReadBytes})`,
+          toolCallId: call.id,
+          toolName: func.name,
+          rawArguments: func.arguments
+        });
+      }
+      maxBytes = requestedMax;
+    }
+    const absPath = await this.resolveAndValidatePath(relPath, call);
+    const stat = await fs.stat(absPath);
+    if (stat.isDirectory()) {
+      throw new Error(`fs.read_file: path is a directory: ${relPath}`);
+    }
+    if (stat.size > maxBytes) {
+      throw new Error(`fs.read_file: file exceeds max_bytes (${maxBytes})`);
+    }
+    const data = await fs.readFile(absPath);
+    if (!this.isValidUtf8(data)) {
+      throw new Error(`fs.read_file: file is not valid UTF-8: ${relPath}`);
+    }
+    return data.toString("utf-8");
+  }
+  async listFiles(_args, call) {
+    const args = this.parseArgs(call, []);
+    const func = call.function;
+    const startPath = this.optionalString(args, "path", call)?.trim() || ".";
+    let maxEntries = this.cfg.maxListEntries;
+    const requestedMax = this.optionalPositiveInt(args, "max_entries", call);
+    if (requestedMax !== void 0) {
+      if (requestedMax > this.cfg.hardMaxListEntries) {
+        throw new ToolArgumentError({
+          message: `max_entries exceeds hard cap (${this.cfg.hardMaxListEntries})`,
+          toolCallId: call.id,
+          toolName: func.name,
+          rawArguments: func.arguments
+        });
+      }
+      maxEntries = requestedMax;
+    }
+    const absPath = await this.resolveAndValidatePath(startPath, call);
+    let rootReal;
+    try {
+      rootReal = await fs.realpath(this.rootAbs);
+    } catch {
+      rootReal = this.rootAbs;
+    }
+    const stat = await fs.stat(absPath);
+    if (!stat.isDirectory()) {
+      throw new Error(`fs.list_files: path is not a directory: ${startPath}`);
+    }
+    const files = [];
+    await this.walkDir(absPath, async (filePath, dirent) => {
+      if (files.length >= maxEntries) {
+        return false;
+      }
+      if (dirent.isDirectory()) {
+        if (this.cfg.ignoreDirs.has(dirent.name)) {
+          return false;
+        }
+        return true;
+      }
+      if (dirent.isFile()) {
+        const relPath = path.relative(rootReal, filePath);
+        files.push(relPath.split(path.sep).join("/"));
+      }
+      return true;
+    });
+    return files.join("\n");
+  }
+  async search(_args, call) {
+    const args = this.parseArgs(call, ["query"]);
+    const func = call.function;
+    const query = this.requireString(args, "query", call);
+    const startPath = this.optionalString(args, "path", call)?.trim() || ".";
+    let maxMatches = this.cfg.maxSearchMatches;
+    const requestedMax = this.optionalPositiveInt(args, "max_matches", call);
+    if (requestedMax !== void 0) {
+      if (requestedMax > this.cfg.hardMaxSearchMatches) {
+        throw new ToolArgumentError({
+          message: `max_matches exceeds hard cap (${this.cfg.hardMaxSearchMatches})`,
+          toolCallId: call.id,
+          toolName: func.name,
+          rawArguments: func.arguments
+        });
+      }
+      maxMatches = requestedMax;
+    }
+    const absPath = await this.resolveAndValidatePath(startPath, call);
+    const rgPath = await this.detectRipgrep();
+    if (rgPath) {
+      return this.searchWithRipgrep(
+        rgPath,
+        query,
+        absPath,
+        maxMatches
+      );
+    }
+    return this.searchWithJS(query, absPath, maxMatches, call);
+  }
+  // ========================================================================
+  // Path Safety
+  // ========================================================================
+  /**
+   * Resolves a workspace-relative path and validates it stays within the sandbox.
+   * @throws {ToolArgumentError} if path is invalid
+   * @throws {PathEscapeError} if resolved path escapes root
+   */
+  async resolveAndValidatePath(relPath, call) {
+    const func = call.function;
+    const cleanRel = relPath.trim();
+    if (!cleanRel) {
+      throw new ToolArgumentError({
+        message: "path cannot be empty",
+        toolCallId: call.id,
+        toolName: func.name,
+        rawArguments: func.arguments
+      });
+    }
+    if (path.isAbsolute(cleanRel)) {
+      throw new ToolArgumentError({
+        message: "path must be workspace-relative (not absolute)",
+        toolCallId: call.id,
+        toolName: func.name,
+        rawArguments: func.arguments
+      });
+    }
+    const normalized = path.normalize(cleanRel);
+    if (normalized.startsWith("..") || normalized.startsWith(`.${path.sep}..`)) {
+      throw new ToolArgumentError({
+        message: "path must not escape the workspace root",
+        toolCallId: call.id,
+        toolName: func.name,
+        rawArguments: func.arguments
+      });
+    }
+    const target = path.join(this.rootAbs, normalized);
+    let rootReal;
+    try {
+      rootReal = await fs.realpath(this.rootAbs);
+    } catch {
+      rootReal = this.rootAbs;
+    }
+    let resolved;
+    try {
+      resolved = await fs.realpath(target);
+    } catch (err) {
+      resolved = path.join(rootReal, normalized);
+    }
+    const relFromRoot = path.relative(rootReal, resolved);
+    if (relFromRoot.startsWith("..") || relFromRoot.startsWith(`.${path.sep}..`) || path.isAbsolute(relFromRoot)) {
+      throw new PathEscapeError({
+        requestedPath: relPath,
+        resolvedPath: resolved
+      });
+    }
+    return resolved;
+  }
+  // ========================================================================
+  // Ripgrep Search
+  // ========================================================================
+  async detectRipgrep() {
+    if (this.rgChecked) {
+      return this.rgPath;
+    }
+    this.rgChecked = true;
+    return new Promise((resolve2) => {
+      const proc = spawn("rg", ["--version"], { stdio: "ignore" });
+      proc.on("error", () => {
+        this.rgPath = null;
+        resolve2(null);
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          this.rgPath = "rg";
+          resolve2("rg");
+        } else {
+          this.rgPath = null;
+          resolve2(null);
+        }
+      });
+    });
+  }
+  async searchWithRipgrep(rgPath, query, dirAbs, maxMatches) {
+    return new Promise((resolve2, reject) => {
+      const args = ["--line-number", "--no-heading", "--color=never"];
+      for (const name of this.cfg.ignoreDirs) {
+        args.push("--glob", `!**/${name}/**`);
+      }
+      args.push(query, dirAbs);
+      const proc = spawn(rgPath, args, {
+        timeout: this.cfg.searchTimeoutMs
+      });
+      const lines = [];
+      let stderr = "";
+      let killed = false;
+      proc.stdout.on("data", (chunk) => {
+        if (killed) return;
+        const text = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+        const newLines = text.split("\n").filter((l) => l.trim());
+        for (const line of newLines) {
+          lines.push(this.normalizeRipgrepLine(line));
+          if (lines.length >= maxMatches) {
+            killed = true;
+            proc.kill();
+            break;
+          }
+        }
+      });
+      proc.stderr.on("data", (chunk) => {
+        stderr += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+      });
+      proc.on("error", (err) => {
+        reject(new Error(`fs.search: ripgrep error: ${err.message}`));
+      });
+      proc.on("close", (code) => {
+        if (killed) {
+          resolve2(lines.join("\n"));
+          return;
+        }
+        if (code === 0 || code === 1) {
+          resolve2(lines.join("\n"));
+        } else if (code === 2 && stderr.toLowerCase().includes("regex")) {
+          reject(
+            new ToolArgumentError({
+              message: `invalid query regex: ${stderr.trim()}`,
+              toolCallId: "",
+              toolName: ToolNames.FS_SEARCH,
+              rawArguments: ""
+            })
+          );
+        } else if (stderr) {
+          reject(new Error(`fs.search: ripgrep failed: ${stderr.trim()}`));
+        } else {
+          resolve2(lines.join("\n"));
+        }
+      });
+    });
+  }
+  normalizeRipgrepLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.includes(":")) {
+      return trimmed;
+    }
+    const colonIdx = trimmed.indexOf(":");
+    const filePath = trimmed.slice(0, colonIdx);
+    const rest = trimmed.slice(colonIdx + 1);
+    if (path.isAbsolute(filePath)) {
+      const rel = path.relative(this.rootAbs, filePath);
+      if (!rel.startsWith("..")) {
+        return rel.split(path.sep).join("/") + ":" + rest;
+      }
+    }
+    return filePath.split(path.sep).join("/") + ":" + rest;
+  }
+  // ========================================================================
+  // JavaScript Fallback Search
+  // ========================================================================
+  async searchWithJS(query, dirAbs, maxMatches, call) {
+    const func = call.function;
+    let regex;
+    try {
+      regex = new RegExp(query);
+    } catch (err) {
+      throw new ToolArgumentError({
+        message: `invalid query regex: ${err.message}`,
+        toolCallId: call.id,
+        toolName: func.name,
+        rawArguments: func.arguments
+      });
+    }
+    const matches = [];
+    const deadline = Date.now() + this.cfg.searchTimeoutMs;
+    await this.walkDir(dirAbs, async (filePath, dirent) => {
+      if (Date.now() > deadline) {
+        return false;
+      }
+      if (matches.length >= maxMatches) {
+        return false;
+      }
+      if (dirent.isDirectory()) {
+        if (this.cfg.ignoreDirs.has(dirent.name)) {
+          return false;
+        }
+        return true;
+      }
+      if (!dirent.isFile()) {
+        return true;
+      }
+      try {
+        const stat = await fs.stat(filePath);
+        if (stat.size > this.cfg.maxSearchBytesPerFile) {
+          return true;
+        }
+      } catch {
+        return true;
+      }
+      try {
+        const content = await fs.readFile(filePath, "utf-8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length && matches.length < maxMatches; i++) {
+          if (regex.test(lines[i])) {
+            const relPath = path.relative(this.rootAbs, filePath);
+            const normalizedPath = relPath.split(path.sep).join("/");
+            matches.push(`${normalizedPath}:${i + 1}:${lines[i]}`);
+          }
+        }
+      } catch {
+      }
+      return true;
+    });
+    return matches.join("\n");
+  }
+  // ========================================================================
+  // Helpers
+  // ========================================================================
+  parseArgs(call, required) {
+    const func = call.function;
+    if (!func) {
+      throw new ToolArgumentError({
+        message: "tool call missing function",
+        toolCallId: call.id,
+        toolName: "",
+        rawArguments: ""
+      });
+    }
+    const rawArgs = func.arguments || "{}";
+    let parsed;
+    try {
+      parsed = JSON.parse(rawArgs);
+    } catch (err) {
+      throw new ToolArgumentError({
+        message: `invalid JSON arguments: ${err.message}`,
+        toolCallId: call.id,
+        toolName: func.name,
+        rawArguments: rawArgs
+      });
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new ToolArgumentError({
+        message: "arguments must be an object",
+        toolCallId: call.id,
+        toolName: func.name,
+        rawArguments: rawArgs
+      });
+    }
+    const args = parsed;
+    for (const key of required) {
+      const value = args[key];
+      if (value === void 0 || value === null || value === "") {
+        throw new ToolArgumentError({
+          message: `${key} is required`,
+          toolCallId: call.id,
+          toolName: func.name,
+          rawArguments: rawArgs
+        });
+      }
+    }
+    return args;
+  }
+  toolArgumentError(call, message) {
+    const func = call.function;
+    throw new ToolArgumentError({
+      message,
+      toolCallId: call.id,
+      toolName: func?.name ?? "",
+      rawArguments: func?.arguments ?? ""
+    });
+  }
+  requireString(args, key, call) {
+    const value = args[key];
+    if (typeof value !== "string") {
+      this.toolArgumentError(call, `${key} must be a string`);
+    }
+    if (value.trim() === "") {
+      this.toolArgumentError(call, `${key} is required`);
+    }
+    return value;
+  }
+  optionalString(args, key, call) {
+    const value = args[key];
+    if (value === void 0 || value === null) {
+      return void 0;
+    }
+    if (typeof value !== "string") {
+      this.toolArgumentError(call, `${key} must be a string`);
+    }
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      return void 0;
+    }
+    return value;
+  }
+  optionalPositiveInt(args, key, call) {
+    const value = args[key];
+    if (value === void 0 || value === null) {
+      return void 0;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) {
+      this.toolArgumentError(call, `${key} must be an integer`);
+    }
+    if (value <= 0) {
+      this.toolArgumentError(call, `${key} must be > 0`);
+    }
+    return value;
+  }
+  isValidUtf8(buffer) {
+    try {
+      const text = buffer.toString("utf-8");
+      return !text.includes("\uFFFD");
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Recursively walks a directory, calling visitor for each entry.
+   * Visitor returns true to continue, false to skip (for dirs) or stop.
+   */
+  async walkDir(dir, visitor) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const shouldContinue = await visitor(fullPath, entry);
+      if (!shouldContinue) {
+        if (entry.isDirectory()) {
+          continue;
+        }
+        return;
+      }
+      if (entry.isDirectory()) {
+        await this.walkDir(fullPath, visitor);
+      }
+    }
+  }
+};
+function createLocalFSToolPack(options) {
+  return new LocalFSToolPack(options);
+}
+function createLocalFSTools(options) {
+  return createLocalFSToolPack(options).toRegistry();
+}
+
+// src/tools_browser.ts
+var BrowserToolNames = {
+  /** Navigate to a URL and return accessibility tree */
+  NAVIGATE: "browser.navigate",
+  /** Click an element by accessible name/role */
+  CLICK: "browser.click",
+  /** Type text into an input field */
+  TYPE: "browser.type",
+  /** Get current accessibility tree */
+  SNAPSHOT: "browser.snapshot",
+  /** Scroll the page */
+  SCROLL: "browser.scroll",
+  /** Capture a screenshot */
+  SCREENSHOT: "browser.screenshot",
+  /** Extract data using CSS selectors */
+  EXTRACT: "browser.extract"
+};
+var BrowserDefaults = {
+  /** Navigation timeout in milliseconds */
+  NAVIGATION_TIMEOUT_MS: 3e4,
+  /** Action timeout in milliseconds */
+  ACTION_TIMEOUT_MS: 5e3,
+  /** Maximum nodes to include in accessibility tree output */
+  MAX_SNAPSHOT_NODES: 500,
+  /** Maximum screenshot size in bytes */
+  MAX_SCREENSHOT_BYTES: 5e6
+};
+var BrowserToolPack = class {
+  constructor(options = {}) {
+    this.browser = null;
+    this.context = null;
+    this.page = null;
+    this.cdpSession = null;
+    this.ownsBrowser = false;
+    this.ownsContext = false;
+    this.cfg = {
+      allowedDomains: options.allowedDomains ?? [],
+      blockedDomains: options.blockedDomains ?? [],
+      navigationTimeoutMs: options.navigationTimeoutMs ?? BrowserDefaults.NAVIGATION_TIMEOUT_MS,
+      actionTimeoutMs: options.actionTimeoutMs ?? BrowserDefaults.ACTION_TIMEOUT_MS,
+      maxSnapshotNodes: options.maxSnapshotNodes ?? BrowserDefaults.MAX_SNAPSHOT_NODES,
+      headless: options.headless ?? true
+    };
+    if (options.browser) {
+      this.browser = options.browser;
+      this.ownsBrowser = false;
+    }
+    if (options.context) {
+      this.context = options.context;
+      this.ownsContext = false;
+    }
+  }
+  /**
+   * Initialize the browser. Must be called before using any tools.
+   */
+  async initialize() {
+    if (this.page) {
+      return;
+    }
+    const { chromium } = await import("playwright");
+    if (!this.browser) {
+      this.browser = await chromium.launch({
+        headless: this.cfg.headless
+      });
+      this.ownsBrowser = true;
+    }
+    if (!this.context) {
+      this.context = await this.browser.newContext();
+      this.ownsContext = true;
+    }
+    this.page = await this.context.newPage();
+  }
+  /**
+   * Close the browser and clean up resources.
+   */
+  async close() {
+    if (this.cdpSession) {
+      await this.cdpSession.detach().catch(() => {
+      });
+      this.cdpSession = null;
+    }
+    if (this.page) {
+      await this.page.close().catch(() => {
+      });
+      this.page = null;
+    }
+    if (this.ownsContext && this.context) {
+      await this.context.close().catch(() => {
+      });
+      this.context = null;
+    }
+    if (this.ownsBrowser && this.browser) {
+      await this.browser.close().catch(() => {
+      });
+      this.browser = null;
+    }
+  }
+  /**
+   * Get tool definitions for use with LLM APIs.
+   */
+  getToolDefinitions() {
+    return [
+      {
+        type: ToolTypes.Function,
+        function: {
+          name: BrowserToolNames.NAVIGATE,
+          description: "Navigate to a URL and return the page's accessibility tree. The tree shows interactive elements (buttons, links, inputs) with their accessible names.",
+          parameters: {
+            type: "object",
+            properties: {
+              url: {
+                type: "string",
+                description: "The URL to navigate to (must be http/https)"
+              },
+              waitUntil: {
+                type: "string",
+                enum: ["load", "domcontentloaded", "networkidle"],
+                description: "When to consider navigation complete. Default: domcontentloaded"
+              }
+            },
+            required: ["url"]
+          }
         }
       },
-      required: [
-        "id",
-        "type"
-      ],
-      type: "object"
-    },
-    output: {
-      additionalProperties: false,
-      properties: {
-        from: {
-          minLength: 1,
-          type: "string"
-        },
-        name: {
-          minLength: 1,
-          type: "string"
-        },
-        pointer: {
-          pattern: "^(/.*)?$",
-          type: "string"
+      {
+        type: ToolTypes.Function,
+        function: {
+          name: BrowserToolNames.CLICK,
+          description: "Click an element by its accessible name. Returns updated accessibility tree.",
+          parameters: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "The accessible name of the element (from button text, aria-label, etc.)"
+              },
+              role: {
+                type: "string",
+                enum: [
+                  "button",
+                  "link",
+                  "menuitem",
+                  "checkbox",
+                  "radio",
+                  "tab"
+                ],
+                description: "ARIA role to match. If omitted, searches buttons, links, and menuitems."
+              }
+            },
+            required: ["name"]
+          }
         }
       },
-      required: [
-        "name",
-        "from"
-      ],
-      type: "object"
-    },
-    transformValue: {
-      additionalProperties: false,
-      properties: {
-        from: {
-          minLength: 1,
-          type: "string"
-        },
-        pointer: {
-          pattern: "^(/.*)?$",
-          type: "string"
+      {
+        type: ToolTypes.Function,
+        function: {
+          name: BrowserToolNames.TYPE,
+          description: "Type text into an input field identified by accessible name.",
+          parameters: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "The accessible name of the input (from label, aria-label, placeholder)"
+              },
+              text: {
+                type: "string",
+                description: "The text to type"
+              },
+              role: {
+                type: "string",
+                enum: ["textbox", "searchbox", "combobox"],
+                description: "ARIA role. Default: textbox"
+              }
+            },
+            required: ["name", "text"]
+          }
         }
       },
-      required: [
-        "from"
-      ],
-      type: "object"
-    }
-  },
-  properties: {
-    edges: {
-      items: {
-        $ref: "#/definitions/edge"
+      {
+        type: ToolTypes.Function,
+        function: {
+          name: BrowserToolNames.SNAPSHOT,
+          description: "Get the current page's accessibility tree without navigating.",
+          parameters: {
+            type: "object",
+            properties: {}
+          }
+        }
       },
-      type: "array"
-    },
-    execution: {
-      additionalProperties: false,
-      properties: {
-        max_parallelism: {
-          minimum: 1,
-          type: "integer"
-        },
-        node_timeout_ms: {
-          minimum: 1,
-          type: "integer"
-        },
-        run_timeout_ms: {
-          minimum: 1,
-          type: "integer"
+      {
+        type: ToolTypes.Function,
+        function: {
+          name: BrowserToolNames.SCROLL,
+          description: "Scroll the page in a given direction.",
+          parameters: {
+            type: "object",
+            properties: {
+              direction: {
+                type: "string",
+                enum: ["up", "down"],
+                description: "Scroll direction"
+              },
+              amount: {
+                type: "string",
+                enum: ["page", "half", "toTop", "toBottom"],
+                description: "How much to scroll. Default: page"
+              }
+            },
+            required: ["direction"]
+          }
         }
       },
-      type: "object"
-    },
-    kind: {
-      const: "workflow.v0",
-      type: "string"
-    },
-    name: {
-      type: "string"
-    },
-    nodes: {
-      items: {
-        $ref: "#/definitions/node"
+      {
+        type: ToolTypes.Function,
+        function: {
+          name: BrowserToolNames.SCREENSHOT,
+          description: "Capture a PNG screenshot of the current page. Use sparingly - prefer accessibility tree for decisions.",
+          parameters: {
+            type: "object",
+            properties: {
+              fullPage: {
+                type: "boolean",
+                description: "Capture full scrollable page. Default: false (viewport only)"
+              }
+            }
+          }
+        }
       },
-      minItems: 1,
-      type: "array"
-    },
-    outputs: {
-      items: {
-        $ref: "#/definitions/output"
+      {
+        type: ToolTypes.Function,
+        function: {
+          name: BrowserToolNames.EXTRACT,
+          description: "Extract structured data from the page using CSS selectors.",
+          parameters: {
+            type: "object",
+            properties: {
+              selector: {
+                type: "string",
+                description: "CSS selector for elements to extract"
+              },
+              attribute: {
+                type: "string",
+                description: "Attribute to extract (textContent, href, src, etc.). Default: textContent"
+              },
+              multiple: {
+                type: "boolean",
+                description: "Return all matches as JSON array. Default: false (first match only)"
+              }
+            },
+            required: ["selector"]
+          }
+        }
+      }
+    ];
+  }
+  /**
+   * Register tool handlers into an existing registry.
+   */
+  registerInto(registry) {
+    registry.register(BrowserToolNames.NAVIGATE, this.navigate.bind(this));
+    registry.register(BrowserToolNames.CLICK, this.click.bind(this));
+    registry.register(BrowserToolNames.TYPE, this.type.bind(this));
+    registry.register(BrowserToolNames.SNAPSHOT, this.snapshot.bind(this));
+    registry.register(BrowserToolNames.SCROLL, this.scroll.bind(this));
+    registry.register(BrowserToolNames.SCREENSHOT, this.screenshot.bind(this));
+    registry.register(BrowserToolNames.EXTRACT, this.extract.bind(this));
+    return registry;
+  }
+  /**
+   * Create a new registry with just this pack's tools.
+   */
+  toRegistry() {
+    return this.registerInto(new ToolRegistry());
+  }
+  // ========================================================================
+  // Private: Helpers
+  // ========================================================================
+  ensureInitialized() {
+    if (!this.page) {
+      throw new Error(
+        "BrowserToolPack not initialized. Call initialize() first."
+      );
+    }
+  }
+  parseArgs(call, required) {
+    const func = call.function;
+    if (!func) {
+      throw new ToolArgumentError({
+        message: "tool call missing function",
+        toolCallId: call.id,
+        toolName: "",
+        rawArguments: ""
+      });
+    }
+    const rawArgs = func.arguments || "{}";
+    let parsed;
+    try {
+      parsed = JSON.parse(rawArgs);
+    } catch (err) {
+      throw new ToolArgumentError({
+        message: `invalid JSON arguments: ${err.message}`,
+        toolCallId: call.id,
+        toolName: func.name,
+        rawArguments: rawArgs
+      });
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new ToolArgumentError({
+        message: "arguments must be an object",
+        toolCallId: call.id,
+        toolName: func.name,
+        rawArguments: rawArgs
+      });
+    }
+    const args = parsed;
+    for (const key of required) {
+      const value = args[key];
+      if (value === void 0 || value === null || value === "") {
+        throw new ToolArgumentError({
+          message: `${key} is required`,
+          toolCallId: call.id,
+          toolName: func.name,
+          rawArguments: rawArgs
+        });
+      }
+    }
+    return args;
+  }
+  validateUrl(url, call) {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      throw new ToolArgumentError({
+        message: `Invalid URL: ${url}`,
+        toolCallId: call.id,
+        toolName: call.function?.name ?? "",
+        rawArguments: call.function?.arguments ?? ""
+      });
+    }
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      throw new ToolArgumentError({
+        message: `Invalid protocol: ${parsed.protocol}. Only http/https allowed.`,
+        toolCallId: call.id,
+        toolName: call.function?.name ?? "",
+        rawArguments: call.function?.arguments ?? ""
+      });
+    }
+    const domain = parsed.hostname;
+    if (this.cfg.blockedDomains.some((d) => domain.endsWith(d))) {
+      throw new ToolArgumentError({
+        message: `Domain blocked: ${domain}`,
+        toolCallId: call.id,
+        toolName: call.function?.name ?? "",
+        rawArguments: call.function?.arguments ?? ""
+      });
+    }
+    if (this.cfg.allowedDomains.length > 0) {
+      if (!this.cfg.allowedDomains.some((d) => domain.endsWith(d))) {
+        throw new ToolArgumentError({
+          message: `Domain not in allowlist: ${domain}`,
+          toolCallId: call.id,
+          toolName: call.function?.name ?? "",
+          rawArguments: call.function?.arguments ?? ""
+        });
+      }
+    }
+  }
+  /**
+   * Validates the current page URL against allowlist/blocklist.
+   * Called after navigation and before any action to catch redirects
+   * and in-session navigation to blocked domains.
+   */
+  ensureCurrentUrlAllowed() {
+    if (!this.page) return;
+    const currentUrl = this.page.url();
+    if (currentUrl === "about:blank") return;
+    let parsed;
+    try {
+      parsed = new URL(currentUrl);
+    } catch {
+      throw new Error(`Current page has invalid URL: ${currentUrl}`);
+    }
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      throw new Error(
+        `Current page protocol not allowed: ${parsed.protocol}. Only http/https allowed.`
+      );
+    }
+    const domain = parsed.hostname;
+    if (this.cfg.blockedDomains.some((d) => domain.endsWith(d))) {
+      throw new Error(`Current page domain is blocked: ${domain}`);
+    }
+    if (this.cfg.allowedDomains.length > 0) {
+      if (!this.cfg.allowedDomains.some((d) => domain.endsWith(d))) {
+        throw new Error(`Current page domain not in allowlist: ${domain}`);
+      }
+    }
+  }
+  async getAccessibilityTree() {
+    this.ensureInitialized();
+    if (!this.cdpSession) {
+      this.cdpSession = await this.page.context().newCDPSession(this.page);
+      await this.cdpSession.send("Accessibility.enable");
+    }
+    const response = await this.cdpSession.send(
+      "Accessibility.getFullAXTree"
+    );
+    return response.nodes;
+  }
+  formatAXTree(nodes) {
+    const lines = [];
+    let count = 0;
+    for (const node of nodes) {
+      if (count >= this.cfg.maxSnapshotNodes) {
+        lines.push(`[truncated at ${this.cfg.maxSnapshotNodes} nodes]`);
+        break;
+      }
+      if (node.ignored) {
+        continue;
+      }
+      const role = node.role?.value || "unknown";
+      const name = node.name?.value || "";
+      if (!name && ["generic", "none", "text"].includes(role)) {
+        continue;
+      }
+      const states = [];
+      if (node.properties) {
+        for (const prop of node.properties) {
+          if (prop.value?.value === true) {
+            const stateName = prop.name;
+            if (["focused", "checked", "disabled", "expanded", "selected"].includes(
+              stateName
+            )) {
+              states.push(stateName);
+            }
+          }
+        }
+      }
+      const stateStr = states.length ? " " + states.join(" ") : "";
+      const nameStr = name ? ` "${name}"` : "";
+      lines.push(`[${role}${nameStr}${stateStr}]`);
+      count++;
+    }
+    return lines.join("\n");
+  }
+  // ========================================================================
+  // Private: Tool Handlers
+  // ========================================================================
+  async navigate(_args, call) {
+    const args = this.parseArgs(call, ["url"]);
+    this.validateUrl(args.url, call);
+    this.ensureInitialized();
+    const waitUntil = args.waitUntil ?? "domcontentloaded";
+    await this.page.goto(args.url, {
+      timeout: this.cfg.navigationTimeoutMs,
+      waitUntil
+    });
+    this.ensureCurrentUrlAllowed();
+    const tree = await this.getAccessibilityTree();
+    return this.formatAXTree(tree);
+  }
+  async click(_args, call) {
+    const args = this.parseArgs(call, ["name"]);
+    this.ensureInitialized();
+    this.ensureCurrentUrlAllowed();
+    let locator;
+    if (args.role) {
+      locator = this.page.getByRole(args.role, {
+        name: args.name
+      });
+    } else {
+      locator = this.page.getByRole("button", { name: args.name }).or(this.page.getByRole("link", { name: args.name })).or(this.page.getByRole("menuitem", { name: args.name }));
+    }
+    await locator.click({ timeout: this.cfg.actionTimeoutMs });
+    const tree = await this.getAccessibilityTree();
+    return this.formatAXTree(tree);
+  }
+  async type(_args, call) {
+    const args = this.parseArgs(call, ["name", "text"]);
+    this.ensureInitialized();
+    this.ensureCurrentUrlAllowed();
+    const role = args.role ?? "textbox";
+    const locator = this.page.getByRole(role, { name: args.name });
+    await locator.fill(args.text, { timeout: this.cfg.actionTimeoutMs });
+    return `Typed "${args.text}" into ${role} "${args.name}"`;
+  }
+  async snapshot(_args, _call) {
+    this.ensureInitialized();
+    this.ensureCurrentUrlAllowed();
+    const tree = await this.getAccessibilityTree();
+    return this.formatAXTree(tree);
+  }
+  async scroll(_args, call) {
+    const args = this.parseArgs(call, ["direction"]);
+    this.ensureInitialized();
+    this.ensureCurrentUrlAllowed();
+    const amount = args.amount ?? "page";
+    if (amount === "toTop") {
+      await this.page.evaluate(() => window.scrollTo(0, 0));
+    } else if (amount === "toBottom") {
+      await this.page.evaluate(
+        () => window.scrollTo(0, document.body.scrollHeight)
+      );
+    } else {
+      const viewport = this.page.viewportSize();
+      const height = viewport?.height ?? 800;
+      const scrollAmount = amount === "half" ? height / 2 : height;
+      const delta = args.direction === "down" ? scrollAmount : -scrollAmount;
+      await this.page.evaluate((d) => window.scrollBy(0, d), delta);
+    }
+    const tree = await this.getAccessibilityTree();
+    return this.formatAXTree(tree);
+  }
+  async screenshot(_args, call) {
+    const args = this.parseArgs(call, []);
+    this.ensureInitialized();
+    this.ensureCurrentUrlAllowed();
+    const buffer = await this.page.screenshot({
+      fullPage: args.fullPage ?? false,
+      type: "png"
+    });
+    if (buffer.length > BrowserDefaults.MAX_SCREENSHOT_BYTES) {
+      throw new Error(
+        `Screenshot size (${buffer.length} bytes) exceeds maximum allowed (${BrowserDefaults.MAX_SCREENSHOT_BYTES} bytes). Try capturing viewport only.`
+      );
+    }
+    const base64 = buffer.toString("base64");
+    return `data:image/png;base64,${base64}`;
+  }
+  async extract(_args, call) {
+    const args = this.parseArgs(call, ["selector"]);
+    this.ensureInitialized();
+    this.ensureCurrentUrlAllowed();
+    const attribute = args.attribute ?? "textContent";
+    const multiple = args.multiple ?? false;
+    if (multiple) {
+      const elements = this.page.locator(args.selector);
+      const count = await elements.count();
+      const results = [];
+      for (let i = 0; i < count; i++) {
+        const el = elements.nth(i);
+        let value;
+        if (attribute === "textContent") {
+          value = await el.textContent();
+        } else {
+          value = await el.getAttribute(attribute);
+        }
+        if (value !== null) {
+          results.push(value.trim());
+        }
+      }
+      return JSON.stringify(results);
+    } else {
+      const el = this.page.locator(args.selector).first();
+      let value;
+      if (attribute === "textContent") {
+        value = await el.textContent();
+      } else {
+        value = await el.getAttribute(attribute);
+      }
+      return value?.trim() ?? "";
+    }
+  }
+};
+function createBrowserToolPack(options = {}) {
+  return new BrowserToolPack(options);
+}
+function createBrowserTools(options = {}) {
+  const pack = new BrowserToolPack(options);
+  return { pack, registry: pack.toRegistry() };
+}
+
+// src/tools_runner.ts
+var ToolRunner = class {
+  constructor(options) {
+    this.registry = options.registry;
+    this.runsClient = options.runsClient;
+    this.customerId = options.customerId;
+    this.onBeforeExecute = options.onBeforeExecute;
+    this.onAfterExecute = options.onAfterExecute;
+    this.onSubmitted = options.onSubmitted;
+    this.onError = options.onError;
+  }
+  /**
+   * Handles a node_waiting event by executing tools and submitting results.
+   *
+   * @param runId - The run ID
+   * @param nodeId - The node ID that is waiting
+   * @param waiting - The waiting state with pending tool calls
+   * @returns The submission response with accepted count and new status
+   *
+   * @example
+   * ```typescript
+   * for await (const event of client.runs.events(runId)) {
+   *   if (event.type === "node_waiting") {
+   *     const result = await runner.handleNodeWaiting(
+   *       runId,
+   *       event.node_id,
+   *       event.waiting
+   *     );
+   *     console.log(`Submitted ${result.accepted} results, status: ${result.status}`);
+   *   }
+   * }
+   * ```
+   */
+  async handleNodeWaiting(runId, nodeId, waiting) {
+    const results = [];
+    for (const pending of waiting.pending_tool_calls) {
+      try {
+        await this.onBeforeExecute?.(pending);
+        const toolCall = createToolCall(
+          pending.tool_call_id,
+          pending.name,
+          pending.arguments
+        );
+        const result = await this.registry.execute(toolCall);
+        results.push(result);
+        await this.onAfterExecute?.(result);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        await this.onError?.(error, pending);
+        results.push({
+          toolCallId: pending.tool_call_id,
+          toolName: pending.name,
+          result: null,
+          error: error.message
+        });
+      }
+    }
+    const response = await this.runsClient.submitToolResults(
+      runId,
+      {
+        node_id: nodeId,
+        step: waiting.step,
+        request_id: waiting.request_id,
+        results: results.map((r) => ({
+          tool_call_id: r.toolCallId,
+          name: r.toolName,
+          output: r.error ? `Error: ${r.error}` : typeof r.result === "string" ? r.result : JSON.stringify(r.result)
+        }))
       },
-      minItems: 1,
-      type: "array"
+      { customerId: this.customerId }
+    );
+    await this.onSubmitted?.(runId, response.accepted, response.status);
+    return {
+      accepted: response.accepted,
+      status: response.status,
+      results
+    };
+  }
+  /**
+   * Processes a stream of run events, automatically handling node_waiting events.
+   *
+   * This is the main entry point for running a workflow with client-side tools.
+   * It yields all events through (including node_waiting after handling).
+   *
+   * @param runId - The run ID to process
+   * @param events - AsyncIterable of run events (from RunsClient.events())
+   * @yields All run events, with node_waiting events handled automatically
+   *
+   * @example
+   * ```typescript
+   * const run = await client.runs.create(workflowSpec);
+   * const eventStream = client.runs.events(run.run_id);
+   *
+   * for await (const event of runner.processEvents(run.run_id, eventStream)) {
+   *   switch (event.type) {
+   *     case "node_started":
+   *       console.log(`Node ${event.node_id} started`);
+   *       break;
+   *     case "node_succeeded":
+   *       console.log(`Node ${event.node_id} succeeded`);
+   *       break;
+   *     case "run_succeeded":
+   *       console.log("Run completed!");
+   *       break;
+   *   }
+   * }
+   * ```
+   */
+  async *processEvents(runId, events) {
+    for await (const event of events) {
+      if (event.type === "node_waiting") {
+        const waitingEvent = event;
+        try {
+          await this.handleNodeWaiting(
+            runId,
+            waitingEvent.node_id,
+            waitingEvent.waiting
+          );
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          await this.onError?.(error);
+          throw error;
+        }
+      }
+      yield event;
     }
-  },
-  required: [
-    "kind",
-    "nodes",
-    "outputs"
-  ],
-  title: "ModelRelay workflow.v0",
-  type: "object"
+  }
+  /**
+   * Checks if a run event is a node_waiting event.
+   * Utility for filtering events when not using processEvents().
+   */
+  static isNodeWaiting(event) {
+    return event.type === "node_waiting";
+  }
+  /**
+   * Checks if a run status is terminal (succeeded, failed, or canceled).
+   * Utility for determining when to stop polling.
+   */
+  static isTerminalStatus(status) {
+    return status === "succeeded" || status === "failed" || status === "canceled";
+  }
 };
+function createToolRunner(options) {
+  return new ToolRunner(options);
+}
 
 // src/generated/index.ts
 var generated_exports = {};
@@ -9156,9 +11562,11 @@ var ModelRelay = class _ModelRelay {
       metrics: cfg.metrics,
       trace: cfg.trace
     });
+    this.images = new ImagesClient(http, auth);
     this.customers = new CustomersClient(http, { apiKey, accessToken, tokenProvider });
     this.tiers = new TiersClient(http, { apiKey });
     this.models = new ModelsClient(http);
+    this.sessions = new SessionsClient(this, http, auth);
   }
   forCustomer(customerId) {
     return new CustomerScopedModelRelay(this.responses, customerId, this.baseUrl);
@@ -9171,6 +11579,10 @@ function resolveBaseUrl(override) {
 export {
   APIError,
   AuthClient,
+  BillingProviders,
+  BrowserDefaults,
+  BrowserToolNames,
+  BrowserToolPack,
   ConfigError,
   ContentPartTypes,
   CustomerResponsesClient,
@@ -9180,10 +11592,17 @@ export {
   DEFAULT_BASE_URL,
   DEFAULT_CLIENT_HEADER,
   DEFAULT_CONNECT_TIMEOUT_MS,
+  DEFAULT_IGNORE_DIRS,
   DEFAULT_REQUEST_TIMEOUT_MS,
   ErrorCodes,
+  FSDefaults,
+  ToolNames as FSToolNames,
   FrontendTokenProvider,
+  ImagesClient,
   InputItemTypes,
+  LocalFSToolPack,
+  LocalSession,
+  MemorySessionStore,
   MessageRoles,
   ModelRelay,
   ModelRelayError,
@@ -9191,22 +11610,27 @@ export {
   OIDCExchangeTokenProvider,
   OutputFormatTypes,
   OutputItemTypes,
+  PathEscapeError,
   ResponsesClient,
   ResponsesStream,
   RunsClient,
   RunsEventStream,
   SDK_VERSION,
+  SessionsClient,
   StopReasons,
   StreamProtocolError,
   StreamTimeoutError,
   StructuredDecodeError,
   StructuredExhaustedError,
   StructuredJSONStream,
+  SubscriptionStatuses,
   TiersClient,
   ToolArgsError,
+  ToolArgumentError,
   ToolCallAccumulator,
   ToolChoiceTypes,
   ToolRegistry,
+  ToolRunner,
   ToolTypes,
   TransportError,
   WORKFLOWS_COMPILE_PATH,
@@ -9218,17 +11642,25 @@ export {
   WorkflowsClient,
   asModelId,
   asProviderId,
+  asSessionId,
   asTierCode,
   assistantMessageWithToolCalls,
   createAccessTokenAuth,
   createApiKeyAuth,
   createAssistantMessage,
+  createBrowserToolPack,
+  createBrowserTools,
   createFunctionCall,
   createFunctionTool,
   createFunctionToolFromSchema,
+  createLocalFSToolPack,
+  createLocalFSTools,
+  createLocalSession,
+  createMemorySessionStore,
   createRetryMessages,
   createSystemMessage,
   createToolCall,
+  createToolRunner,
   createUsage,
   createUserMessage,
   createWebTool,
@@ -9236,6 +11668,7 @@ export {
   executeWithRetry,
   firstToolCall,
   formatToolErrorForModel,
+  generateSessionId,
   generated_exports as generated,
   getRetryableErrors,
   hasRetryableErrors,