@desplega.ai/agent-swarm 2.4.4 → 2.5.0

package/dist/{cli-b9fcxxev.js → cli-007cnhm1.js}

@@ -3,13 +3,14 @@ import {
   requiredNumber,
   postClassifierRequest,
   parseClassifierUsage
-} from "./cli-sm8rses9.js";
+} from "./cli-zfdp01hn.js";
 import {
   normalizeProviderError,
   formatProviderError
 } from "./cli-bh87e0rh.js";
 
 // node_modules/@earendil-works/pi-ai/dist/api/system-one-shared.js
+var IMAGE_OPT_IN_HEADERS = { "TypeSafe-Danger-Zone-Images": "true" };
 function probabilities(label, value, id) {
   if (!isRecord(value))
     throw new Error(`${label} returned invalid probabilities for ${id}`);
@@ -64,6 +65,40 @@ function parseAnswers(label, value, context) {
   }
   return Object.fromEntries(answers);
 }
+var ASSET_FORMATS = { "image/png": "png", "image/jpeg": "jpeg" };
+var DATA_URL_TYPES = new Set(["image/png", "image/jpeg", "image/webp"]);
+var MAX_DATA_URL_IMAGES = 4;
+function addImages(label, model, input, images, request) {
+  if (input === "images") {
+    if (images.length > MAX_DATA_URL_IMAGES) {
+      throw new Error(`${label} accepts at most ${MAX_DATA_URL_IMAGES} images for ${model.id}, got ${images.length}`);
+    }
+    request.images = images.map((image) => {
+      if (!DATA_URL_TYPES.has(image.mimeType)) {
+        throw new Error(`${label} accepts PNG, JPEG, and WebP images for ${model.id}, got ${image.mimeType}`);
+      }
+      return `data:${image.mimeType};base64,${image.data}`;
+    });
+    return;
+  }
+  if (input === "state-image-urls") {
+    const parts = images.map((image) => ({
+      type: "image_url",
+      image_url: { url: `data:${image.mimeType};base64,${image.data}` }
+    }));
+    request.state = [...parts, request.state];
+    return;
+  }
+  const assets = {};
+  images.forEach((image, index) => {
+    const format = ASSET_FORMATS[image.mimeType];
+    if (!format)
+      throw new Error(`${label} accepts PNG and JPEG images for ${model.id}, got ${image.mimeType}`);
+    assets[`<image-${index + 1}>`] = { type: "image", format, data_base64: image.data };
+  });
+  request.assets = assets;
+  request.state = [...Object.keys(assets), request.state];
+}
 function wireRequest(context) {
   return {
     state: context.state,
@@ -85,9 +120,20 @@ async function classifySystemOne(transport, model, context, options) {
   try {
     if (model.api !== transport.api)
       throw new Error(`Unsupported classifier API: ${model.api}`);
-    if (context.images?.length)
-      throw new Error(`${transport.label} does not support image input`);
-    const body = await postClassifierRequest(transport.label, transport.url(model), model, transport.payload(model, wireRequest(context)), options);
+    const request = wireRequest(context);
+    let requestOptions = options;
+    if (context.images?.length) {
+      if (!model.input.includes("image")) {
+        throw new Error(`${transport.label} does not support image input for ${model.id}`);
+      }
+      const detected = transport.detectCompat(model);
+      const imageInput = model.compat?.imageInput ?? detected.imageInput;
+      addImages(transport.label, model, imageInput, context.images, request);
+      if (model.compat?.sendImageOptInHeader ?? detected.sendImageOptInHeader) {
+        requestOptions = { ...options, headers: { ...IMAGE_OPT_IN_HEADERS, ...options?.headers } };
+      }
+    }
+    const body = await postClassifierRequest(transport.label, transport.url(model), model, transport.payload(model, request), requestOptions);
     const result = transport.output(body);
     const usage = parseClassifierUsage(result.usage, model);
     if (usage)

package/dist/{cli-j4rqdf2n.js → cli-03vpq45j.js}

@@ -9,7 +9,7 @@ import {
   loadMcpConfig,
   addMcpServerConfig,
   removeMcpServerConfig
-} from "./cli-d2mb5s8a.js";
+} from "./cli-x77gen2p.js";
 import {
   McpOAuthCredentialStore2,
   McpSignInCancelledError2,
@@ -17,7 +17,7 @@ import {
   McpServerLog2,
   createDefaultTransport2,
   McpServerConnection2
-} from "./cli-wxbn3yfx.js";
+} from "./cli-cz5nmdxt.js";
 
 // node_modules/@earendil-works/pi-coding-agent/dist/extensions/mcp/cli.js
 import { existsSync } from "node:fs";

package/dist/{cli-amyhm3gj.js → cli-0y6f0ckq.js}

@@ -1,7 +1,7 @@
 import {
   getDb2,
   init_db3
-} from "./cli-p20r8w42.js";
+} from "./cli-fcc5qe3f.js";
 import {
   openAICompatibleProviderIds,
   withRegistryCatalogSections,

package/dist/{cli-4dg55wsk.js → cli-0z3vjrpm.js}

@@ -2,7 +2,7 @@ import {
   getDb2,
   getDbClient2,
   init_db3
-} from "./cli-p20r8w42.js";
+} from "./cli-fcc5qe3f.js";
 import {
   PermissionVerbSchema,
   init_rbac

package/dist/{cli-pccfmtb5.js → cli-179xcyky.js}

@@ -7,7 +7,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@desplega.ai/agent-swarm",
-    version: "2.4.4",
+    version: "2.5.0",
     description: "agent-swarm.dev — an open-source operating system for AI work: a lead agent breaks goals into tasks, routes them to specialized workers such as Claude Code or Codex, runs each worker in an isolated container, and preserves shared memory, tools, schedules, and review gates so delegated work compounds across sessions.",
     keywords: [
       "agent-swarm.dev",
@@ -186,8 +186,8 @@ var init_package = __esm(() => {
       "@desplega/model-catalog": "workspace:*",
       "@desplega/model-routing": "workspace:*",
       "@faker-js/faker": "^10.4.0",
-      "@opencode/plugin": "2.1.1",
-      "@opencode/sdk": "2.1.1",
+      "@opencode/plugin": "2.1.3",
+      "@opencode/sdk": "2.1.3",
       "@oxlint/plugins": "1.78.0",
       "@types/bun": "latest",
       "dependency-cruiser": "^18.0.0",
@@ -205,26 +205,26 @@ var init_package = __esm(() => {
       bun: ">=1.3.12"
     },
     dependencies: {
-      "@agentclientprotocol/sdk": "2.0.0",
+      "@agentclientprotocol/sdk": "2.0.1",
       "@ai-sdk/openai": "^3.0.41",
-      "@anthropic-ai/claude-agent-sdk": "0.3.304",
-      "@anthropic-ai/sdk": "^0.135.0",
+      "@anthropic-ai/claude-agent-sdk": "0.3.308",
+      "@anthropic-ai/sdk": "^1.1.0",
       "@asteasolutions/zod-to-openapi": "^8.0.0",
       "@aws-sdk/client-bedrock": "3.1048.0",
       "@chat-adapter/discord": "4.41.1",
       "@chat-adapter/slack": "4.41.1",
       "@chat-adapter/teams": "4.41.1",
       "@chat-adapter/telegram": "4.41.1",
-      "@cursor/sdk": "1.0.38",
+      "@cursor/sdk": "1.0.40",
       "@desplega.ai/agent-fs-just-bash": "0.18.5",
       "@desplega.ai/business-use": "^0.4.2",
-      "@earendil-works/pi-agent-core": "^1.3.0",
-      "@earendil-works/pi-ai": "^1.3.0",
-      "@earendil-works/pi-coding-agent": "^1.3.0",
+      "@earendil-works/pi-agent-core": "^1.4.0",
+      "@earendil-works/pi-ai": "^1.4.0",
+      "@earendil-works/pi-coding-agent": "^1.4.0",
       "@inkjs/ui": "^2.0.0",
       "@jitl/quickjs-singlefile-mjs-release-sync": "0.32.0",
       "@linear/sdk": "^77.0.0",
-      "@modelcontextprotocol/sdk": "1.31.0",
+      "@modelcontextprotocol/sdk": "1.32.1",
       "@openai/codex": "0.163.0",
       "@openfort/openfort-node": "^0.9.1",
       "@opentelemetry/api": "^1.9.1",

package/dist/{cli-3r8samv3.js → cli-1f0gp9vz.js}

@@ -1,7 +1,7 @@
 import {
   getSystemMessageText,
   clampThinkingLevel
-} from "./cli-0bqteszy.js";
+} from "./cli-2nf3b08t.js";
 
 // node_modules/@earendil-works/pi-ai/dist/api/constrained-sampling.js
 class UnsupportedStrictJsonSchemaError extends Error {
@@ -332,13 +332,14 @@ function buildBaseOptions(model, context, options, apiKey) {
     samplingParams,
     maxTokens: clampMaxTokensToContext(model, context, options?.maxTokens ?? model.maxTokens),
     signal: options?.signal,
-    telemetryContext: options?.telemetryContext,
+    telemetry: options?.telemetry,
     apiKey: apiKey || options?.apiKey,
     fetch: options?.fetch,
     transport: options?.transport,
     cacheRetention: options?.cacheRetention,
     sessionId: options?.sessionId,
     headers: options?.headers,
+    identity: options?.identity,
     onPayload: options?.onPayload,
     onResponse: options?.onResponse,
     onProviderStreamEvent: options?.onProviderStreamEvent,

package/dist/{cli-hj3debgw.js → cli-1pr672hz.js}

@@ -6,11 +6,11 @@ import {
   getResolvedConfig2,
   getAllUsers2,
   init_db3
-} from "./cli-p20r8w42.js";
+} from "./cli-fcc5qe3f.js";
 import {
   scrubSecrets,
   init_secret_scrubber
-} from "./cli-xf234ws8.js";
+} from "./cli-n4c8e3s5.js";
 
 // src/be/seed/agent-fs-provision.ts
 init_secret_scrubber();
@@ -122,7 +122,7 @@ async function ensureAgentFsSharedProvisioning(options) {
     await upsertSwarmConfig2({ scope: "global", key, value, isSecret: false, description });
   }
   process.env.AGENT_FS_API_URL = apiUrl;
-  const { resetFileStorageProvider } = await import("./registry-rxw10xzg.js");
+  const { resetFileStorageProvider } = await import("./registry-ajhexe44.js");
   resetFileStorageProvider();
   return { apiUrl, apiKey, orgId, driveId, authHeaders };
 }

package/dist/{cli-0bqteszy.js → cli-2nf3b08t.js}

@@ -2,6 +2,29 @@ import {
   AssistantMessageEventStream,
   formatThrownValue
 } from "./cli-m6m1bvtp.js";
+import {
+  mergeClientIdentity,
+  getOpenCodeSessionHeaders
+} from "./cli-pkaqk57w.js";
+import {
+  __export
+} from "./cli-242037k3.js";
+
+// node_modules/@earendil-works/pi-ai/dist/models.js
+var exports_models = {};
+__export(exports_models, {
+  AI_TELEMETRY_SCHEMA: () => AI_TELEMETRY_SCHEMA,
+  ModelsError: () => ModelsError,
+  calculateCost: () => calculateCost,
+  clampThinkingLevel: () => clampThinkingLevel,
+  createModels: () => createModels,
+  createProvider: () => createProvider,
+  getModelType: () => getModelType,
+  getSupportedThinkingLevels: () => getSupportedThinkingLevels,
+  hasApi: () => hasApi,
+  isModelType: () => isModelType,
+  modelsAreEqual: () => modelsAreEqual
+});
 
 // node_modules/@earendil-works/pi-ai/dist/api/lazy.js
 function createSetupErrorMessage(model, error, timestamp) {
@@ -27,19 +50,38 @@ function createSetupErrorMessage(model, error, timestamp) {
 function hasResult(source) {
   return typeof source.result === "function";
 }
-async function forwardStream(target, source) {
+async function forwardStream(target, source, observer, observeResult) {
+  let result;
   for await (const event of source) {
     target.push(event);
-  }
-  target.end(hasResult(source) ? await source.result() : undefined);
+    observer?.onEvent?.(event);
+    if (event.type === "done")
+      result = event.message;
+    else if (event.type === "error")
+      result = event.error;
+  }
+  if (hasResult(source))
+    result = await source.result();
+  target.end(result);
+  observeResult(result);
 }
-function lazyStream(model, setup) {
+function lazyStream(model, setup, observer) {
   const startedAt = Date.now();
   const outer = new AssistantMessageEventStream;
-  setup().then((inner) => forwardStream(outer, inner)).catch((error) => {
+  let observedResult = false;
+  const observeResult = (result) => {
+    if (observedResult)
+      return;
+    observedResult = true;
+    observer?.onResult?.(result);
+  };
+  setup().then((inner) => forwardStream(outer, inner, observer, observeResult)).catch((error) => {
     const message = createSetupErrorMessage(model, error, startedAt);
-    outer.push({ type: "error", reason: "error", error: message });
+    const event = { type: "error", reason: "error", error: message };
+    outer.push(event);
+    observer?.onEvent?.(event);
     outer.end(message);
+    observeResult(message);
   });
   return outer;
 }
@@ -331,6 +373,251 @@ class InMemoryModelsStore {
   }
 }
 
+// node_modules/@earendil-works/pi-telemetry/dist/metrics.js
+function createTypedMetrics(metrics, schemas) {
+  const definitions = new Map;
+  for (const schema of schemas) {
+    for (const [name, definition] of Object.entries(schema.metrics ?? {}))
+      definitions.set(name, definition);
+  }
+  return {
+    counter: (name) => metrics.counter(name, definitions.get(name)),
+    upDownCounter: (name) => metrics.upDownCounter(name, definitions.get(name)),
+    histogram: (name) => metrics.histogram(name, definitions.get(name))
+  };
+}
+// node_modules/@earendil-works/pi-telemetry/dist/noop.js
+async function startNoopSpan(_options, callback) {
+  return callback(noopTelemetrySpan);
+}
+var noopCounter = Object.freeze({ add: () => {} });
+var noopUpDownCounter = Object.freeze({ add: () => {} });
+var noopHistogram = Object.freeze({ record: () => {} });
+var NOOP_TELEMETRY_METRICS = Object.freeze({
+  counter: () => noopCounter,
+  upDownCounter: () => noopUpDownCounter,
+  histogram: () => noopHistogram
+});
+var NOOP_TELEMETRY_PROPAGATION = Object.freeze({
+  inject: () => {
+    return;
+  },
+  extract: () => NOOP_TELEMETRY_CONTEXT
+});
+var noopTelemetrySpan = {
+  metrics: NOOP_TELEMETRY_METRICS,
+  propagation: NOOP_TELEMETRY_PROPAGATION,
+  startSpan: startNoopSpan,
+  addLink: () => {},
+  addEvent: () => {},
+  setAttributes: () => {},
+  setStatus: () => {}
+};
+Object.freeze(noopTelemetrySpan);
+var NOOP_TELEMETRY_CONTEXT = noopTelemetrySpan;
+// node_modules/@earendil-works/pi-telemetry/dist/memory.js
+var contextCarriers = new WeakMap;
+
+// node_modules/@earendil-works/pi-telemetry/dist/index.js
+function defineTelemetrySchema(schema) {
+  return schema;
+}
+function bindTypedSpanStarter(telemetryContext) {
+  const startSpan = (name, attributes, callback) => telemetryContext.startSpan({ name, attributes }, (span) => callback(span, bindTypedSpanStarter(span)));
+  return startSpan;
+}
+function createTypedSpanStarter(telemetryContext, _schemas) {
+  return bindTypedSpanStarter(telemetryContext);
+}
+
+// node_modules/@earendil-works/pi-ai/dist/telemetry.js
+var provider = { type: "string", description: "Provider identifier.", required: true };
+var model = { type: "string", description: "Requested model identifier.", required: true };
+var stop = {
+  type: "string",
+  description: "Normalized stop reason.",
+  values: ["pending", "stop", "length", "toolUse", "error", "aborted", "deferred"]
+};
+var request = {
+  description: "One logical model request, including authentication and provider setup.",
+  parents: { kind: "any" },
+  startAttributes: {
+    provider,
+    api: { type: "string", description: "API identifier.", required: true },
+    model,
+    reasoning: { type: "string", description: "Scalar requested reasoning level.", required: false }
+  },
+  endAttributes: {
+    stop,
+    "usage.input": { type: "number", description: "Uncached input tokens." },
+    "usage.output": { type: "number", description: "Output tokens." },
+    "usage.cache_read": { type: "number", description: "Cache-read tokens." },
+    "usage.cache_write": { type: "number", description: "Cache-write tokens." },
+    "cost.total": { type: "number", description: "Total request cost in USD." },
+    "response.id": { type: "string", description: "Provider response identifier.", cardinality: "high" }
+  },
+  events: {
+    "pi.ai.first_chunk": { description: "First normalized stream event delivered.", attributes: {} },
+    "pi.ai.block": {
+      description: "A completed content block; content is never recorded.",
+      attributes: {
+        type: {
+          type: "string",
+          description: "Block kind.",
+          values: ["text", "thinking", "tool_call"],
+          required: true
+        },
+        index: { type: "number", description: "Content block index.", required: true },
+        chars: { type: "number", description: "UTF-16 character count.", required: true },
+        tool: { type: "string", description: "Tool name, for tool-call blocks only.", required: false }
+      }
+    }
+  },
+  status: {
+    default: "ok",
+    errorWhen: "Stop reason is error: provider_error with at most 500 error-message characters. Aborted stays ok."
+  }
+};
+var AI_TELEMETRY_SCHEMA = defineTelemetrySchema({
+  version: 1,
+  spans: {
+    "pi.ai.request": request,
+    "pi.ai.poll": { ...request, description: "One deferred-response poll, not the deferred request's lifetime." }
+  },
+  metrics: {
+    "pi.ai.request.duration": {
+      kind: "histogram",
+      description: "Logical request or poll duration.",
+      unit: "ms",
+      attributes: { provider, model, stop: { ...stop, required: true } }
+    },
+    "pi.ai.first_chunk.duration": {
+      kind: "histogram",
+      description: "Time to the first normalized stream event.",
+      unit: "ms",
+      attributes: { provider, model }
+    },
+    "pi.ai.tokens": {
+      kind: "counter",
+      description: "Reported model token usage; pending and deferred polls are excluded.",
+      unit: "token",
+      attributes: {
+        provider,
+        model,
+        kind: {
+          type: "string",
+          description: "Token usage category.",
+          values: ["input", "output", "cache_read", "cache_write"],
+          required: true
+        }
+      }
+    },
+    "pi.ai.cost": {
+      kind: "counter",
+      description: "Reported model cost; pending and deferred polls are excluded.",
+      unit: "USD",
+      attributes: { provider, model }
+    }
+  }
+});
+function createInstruments(adapter) {
+  const metrics = createTypedMetrics(adapter, [AI_TELEMETRY_SCHEMA]);
+  return {
+    requestDuration: metrics.histogram("pi.ai.request.duration"),
+    firstChunkDuration: metrics.histogram("pi.ai.first_chunk.duration"),
+    tokens: metrics.counter("pi.ai.tokens"),
+    cost: metrics.counter("pi.ai.cost")
+  };
+}
+var instrumentCache = new WeakMap;
+function observeModelRequest(requestedModel, options, poll) {
+  const started = performance.now();
+  const attributes = { provider: requestedModel.provider, model: requestedModel.id };
+  const adapter = options?.telemetry?.metrics ?? NOOP_TELEMETRY_METRICS;
+  let instruments = instrumentCache.get(adapter);
+  if (!instruments) {
+    instruments = createInstruments(adapter);
+    instrumentCache.set(adapter, instruments);
+  }
+  const { requestDuration, firstChunkDuration, tokens, cost } = instruments;
+  let span;
+  let finish;
+  let first = true;
+  const toolChars = new Map;
+  const finished = new Promise((resolve) => {
+    finish = resolve;
+  });
+  const run = (activeSpan) => {
+    span = activeSpan;
+    return finished;
+  };
+  const startAttributes = {
+    ...attributes,
+    api: requestedModel.api,
+    ...typeof options?.reasoning === "string" ? { reasoning: options.reasoning } : {}
+  };
+  const start = createTypedSpanStarter(options?.telemetry ?? NOOP_TELEMETRY_CONTEXT, [AI_TELEMETRY_SCHEMA]);
+  if (poll)
+    start("pi.ai.poll", startAttributes, run);
+  else
+    start("pi.ai.request", startAttributes, run);
+  return {
+    onEvent(event) {
+      if (first) {
+        first = false;
+        span.addEvent("pi.ai.first_chunk");
+        firstChunkDuration.record(performance.now() - started, attributes, span);
+      }
+      if (event.type === "toolcall_delta") {
+        toolChars.set(event.contentIndex, (toolChars.get(event.contentIndex) ?? 0) + event.delta.length);
+      } else if (event.type === "text_end" || event.type === "thinking_end") {
+        span.addEvent("pi.ai.block", {
+          type: event.type === "text_end" ? "text" : "thinking",
+          index: event.contentIndex,
+          chars: event.content.length
+        });
+      } else if (event.type === "toolcall_end") {
+        const chars = toolChars.get(event.contentIndex) ?? 0;
+        toolChars.delete(event.contentIndex);
+        span.addEvent("pi.ai.block", {
+          type: "tool_call",
+          index: event.contentIndex,
+          chars,
+          tool: event.toolCall.name
+        });
+      }
+    },
+    onResult(message) {
+      if (message) {
+        span.setAttributes({
+          stop: message.stopReason,
+          "usage.input": message.usage.input,
+          "usage.output": message.usage.output,
+          "usage.cache_read": message.usage.cacheRead,
+          "usage.cache_write": message.usage.cacheWrite,
+          "cost.total": message.usage.cost.total,
+          "response.id": message.responseId
+        });
+        if (message.stopReason === "error") {
+          span.setStatus({
+            status: "error",
+            error: { name: "provider_error", message: message.errorMessage?.slice(0, 500) ?? "" }
+          });
+        }
+        requestDuration.record(performance.now() - started, { ...attributes, stop: message.stopReason }, span);
+        if (!poll || message.stopReason !== "pending" && message.stopReason !== "deferred") {
+          tokens.add(message.usage.input, { ...attributes, kind: "input" });
+          tokens.add(message.usage.output, { ...attributes, kind: "output" });
+          tokens.add(message.usage.cacheRead, { ...attributes, kind: "cache_read" });
+          tokens.add(message.usage.cacheWrite, { ...attributes, kind: "cache_write" });
+          cost.add(message.usage.cost.total, attributes);
+        }
+      }
+      finish();
+    }
+  };
+}
+
 // node_modules/@earendil-works/pi-ai/dist/utils/model-operations.js
 function getModelType(model) {
   return model.type ?? "chat";
@@ -546,26 +833,32 @@ function hasToolRedefinitions(messages) {
   return false;
 }
 function hasNonAdditiveToolChanges(messages) {
+  return findLastNonAdditiveToolChange(messages.filter(isSystemMessage)) >= 0;
+}
+function findLastNonAdditiveToolChange(systemMessages) {
   const declared = new Set;
-  for (const message of messages) {
-    if (!isSystemMessage(message))
-      continue;
+  let last = -1;
+  for (let index = 0;index < systemMessages.length; index++) {
+    const message = systemMessages[index];
     if ((message.toolsRemoved?.length ?? 0) > 0)
-      return true;
+      last = index;
     for (const tool of message.toolsAdded ?? []) {
       if (declared.has(tool.name))
-        return true;
+        last = index;
       declared.add(tool.name);
     }
   }
-  return false;
+  return last;
 }
-function resolveTranscriptTools(messages, supportsToolAdditions) {
-  const anchorsAdditions = supportsToolAdditions && !hasNonAdditiveToolChanges(messages);
-  return {
-    requestTools: anchorsAdditions ? getInitialSystemMessage(messages)?.toolsAdded ?? [] : getCurrentTools(messages),
-    anchorsAdditions
-  };
+function resolveTranscriptTools(messages, support) {
+  const systemMessages = messages.filter(isSystemMessage);
+  if (support === "none") {
+    return { requestTools: getCurrentTools(systemMessages), foldedSystemMessages: systemMessages.length };
+  }
+  if (support === "changes")
+    return { requestTools: [], foldedSystemMessages: 0 };
+  const folded = Math.max(getInitialSystemMessage(messages) ? 1 : 0, findLastNonAdditiveToolChange(systemMessages) + 1);
+  return { requestTools: getCurrentTools(systemMessages.slice(0, folded)), foldedSystemMessages: folded };
 }
 
 // node_modules/@earendil-works/pi-ai/dist/models.js
@@ -596,6 +889,7 @@ class ModelsImpl {
   credentials;
   modelsStore;
   authContext;
+  identity;
   refreshGenerations = new Map;
   refreshControllers = new Map;
   publicationChains = new Map;
@@ -603,6 +897,7 @@ class ModelsImpl {
     this.credentials = options?.credentials ?? new InMemoryCredentialStore;
     this.modelsStore = options?.modelsStore ?? new InMemoryModelsStore;
     this.authContext = options?.authContext ?? defaultProviderAuthContext();
+    this.identity = options?.identity;
   }
   setProvider(provider) {
     this.supersedeProviderRefresh(provider.id);
@@ -967,13 +1262,21 @@ class ModelsImpl {
     }
     const auth = resolution.auth;
     const apiKey = options?.apiKey ?? auth.apiKey;
-    let headers = mergeHeaders(auth.headers, options?.headers);
+    const requestModel = auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model;
+    const sessionId = options && "sessionId" in options && typeof options.sessionId === "string" ? options.sessionId : undefined;
+    let headers = mergeHeaders(mergeHeaders(getOpenCodeSessionHeaders(requestModel, sessionId), auth.headers), options?.headers);
     if (options?.transformHeaders)
       headers = await options.transformHeaders(headers ?? {});
     const env = resolution.env || options?.env ? { ...resolution.env ?? {}, ...options?.env ?? {} } : undefined;
-    const requestModel = auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model;
+    const identity = mergeClientIdentity(this.identity, options?.identity);
     const { transformHeaders: _transformHeaders, ...providerOptions } = options ?? {};
-    const requestOptions = { ...providerOptions, apiKey, headers, env };
+    const requestOptions = {
+      ...providerOptions,
+      apiKey,
+      headers,
+      env,
+      ...identity === undefined ? {} : { identity }
+    };
     return { requestModel, requestOptions };
   }
   stream(model, context, options) {
@@ -982,7 +1285,7 @@ class ModelsImpl {
       const provider = this.requireChatProvider(model);
       const { requestModel, requestOptions } = await this.applyAuth(model, options);
       return provider.stream(requestModel, transcript, requestOptions);
-    });
+    }, observeModelRequest(model, options, false));
   }
   async complete(model, context, options) {
     return this.stream(model, context, options).result();
@@ -993,7 +1296,7 @@ class ModelsImpl {
       const provider = this.requireChatProvider(model);
       const { requestModel, requestOptions } = await this.applyAuth(model, options);
       return provider.streamSimple(requestModel, transcript, requestOptions);
-    });
+    }, observeModelRequest(model, options, false));
   }
   async completeSimple(model, context, options) {
     return this.streamSimple(model, context, options).result();
@@ -1006,7 +1309,7 @@ class ModelsImpl {
       }
       const { requestModel, requestOptions } = await this.applyAuth(model, options);
       return provider.fetchDeferred(requestModel, handle, requestOptions);
-    });
+    }, observeModelRequest(model, options, true));
   }
   async fetchDeferred(model, handle, options) {
     return this.streamDeferred(model, handle, options).result();
@@ -1220,4 +1523,4 @@ function modelsAreEqual(a, b) {
   return getModelType(a) === getModelType(b) && a.id === b.id && a.provider === b.provider;
 }
 
-export { lazyStream, lazyApi, defaultProviderAuthContext, InMemoryCredentialStore, ModelsError, InMemoryModelsStore, getModelType, isModelType, assertChatModel, assertImageModel, assertClassifierModel, assertClassifierInputSupported, imageErrorResult, classifierErrorResult, contentText, getSystemMessageText, renderSystemMessageUpdate, createInitialSystemMessage, normalizeContext, getInitialSystemMessage, withoutInitialSystemMessage, getCurrentTools, getCurrentSystemMessage, getCurrentSystemPrompt, collapseSystemMessages, resolveTranscript, toToolDeclaration, declarationsEqual, getToolStateChanges, getDeclaredTools, hasToolRedefinitions, hasNonAdditiveToolChanges, resolveTranscriptTools, createModels, createProvider, hasApi, calculateCost, getSupportedThinkingLevels, clampThinkingLevel, modelsAreEqual };
+export { lazyStream, lazyApi, defaultProviderAuthContext, InMemoryCredentialStore, ModelsError, InMemoryModelsStore, AI_TELEMETRY_SCHEMA, getModelType, isModelType, assertChatModel, assertImageModel, assertClassifierModel, assertClassifierInputSupported, imageErrorResult, classifierErrorResult, contentText, getSystemMessageText, renderSystemMessageUpdate, createInitialSystemMessage, normalizeContext, getInitialSystemMessage, withoutInitialSystemMessage, getCurrentTools, getCurrentSystemMessage, getCurrentSystemPrompt, collapseSystemMessages, resolveTranscript, toToolDeclaration, declarationsEqual, getToolStateChanges, getDeclaredTools, hasToolRedefinitions, hasNonAdditiveToolChanges, resolveTranscriptTools, createModels, createProvider, hasApi, calculateCost, getSupportedThinkingLevels, clampThinkingLevel, modelsAreEqual, exports_models };