@desplega.ai/agent-swarm 2.4.5 → 2.5.1

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 };