@acosmi/sdk-ts 1.0.2 → 1.1.0

package/dist/index.mjs

@@ -1972,8 +1972,25 @@ function extractAnthropicBlockMeta(eventType, data, blockTypeMap) {
   }
 }
 
-// src/index.ts
-init_betas();
+// src/agent-runs-types.ts
+var AgentRunStreamError = class extends Error {
+  event;
+  code;
+  stage;
+  retryable;
+  constructor(event) {
+    const err = event.error;
+    super(err.stage ? `agent run failed: ${err.stage}: ${err.message}` : `agent run failed: ${err.message}`);
+    this.name = "AgentRunStreamError";
+    this.event = event;
+    this.code = err.code ?? "";
+    this.stage = err.stage ?? "";
+    this.retryable = err.retryable ?? false;
+  }
+};
+
+// src/client/agent-runs.ts
+init_types();
 
 // src/client.ts
 init_types();
@@ -3254,6 +3271,487 @@ async function sleep(ms, signal) {
   });
 }
 
+// src/client/agent-runs.ts
+var agentRunsByClient = /* @__PURE__ */ new WeakMap();
+Object.defineProperty(Client.prototype, "agentRuns", {
+  configurable: true,
+  enumerable: false,
+  get() {
+    let existing = agentRunsByClient.get(this);
+    if (!existing) {
+      existing = new AgentRunsClient(this);
+      agentRunsByClient.set(this, existing);
+    }
+    return existing;
+  }
+});
+var AgentRunsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async create(req, signal) {
+    const resp = await this.requestAPI(
+      "POST",
+      "/agent-runs",
+      toWireCreateRequest(req),
+      signal,
+      { retryOn401: false }
+    );
+    return fromWireCreateResponse(resp);
+  }
+  get(runId, signal) {
+    return this.requestAPI(
+      "GET",
+      `/agent-runs/${encodeURIComponent(runId)}`,
+      null,
+      signal,
+      { retryOn401: true }
+    ).then(fromWireRun);
+  }
+  stream(runId, opts = {}, signal) {
+    return {
+      [Symbol.asyncIterator]: () => this.streamGen(runId, opts, signal)
+    };
+  }
+  cancel(runId, signal) {
+    return this.requestAPI(
+      "POST",
+      `/agent-runs/${encodeURIComponent(runId)}/cancel`,
+      {},
+      signal,
+      { retryOn401: false }
+    ).then(fromWireRun);
+  }
+  listArtifacts(runId, signal) {
+    return this.requestAPI(
+      "GET",
+      `/agent-runs/${encodeURIComponent(runId)}/artifacts`,
+      null,
+      signal,
+      { retryOn401: true }
+    ).then((r) => (r.artifacts ?? []).map(fromWireArtifact));
+  }
+  async downloadArtifact(runId, artifactId, signal) {
+    const resp = await this.requestRaw(
+      "GET",
+      `/agent-runs/${encodeURIComponent(runId)}/artifacts/${encodeURIComponent(artifactId)}`,
+      null,
+      signal,
+      { retryOn401: true }
+    );
+    const contentType = resp.headers.get("Content-Type") ?? void 0;
+    const filename = filenameFromContentDisposition(resp.headers.get("Content-Disposition")) ?? artifactId;
+    const data = await readLimited(resp.body, maxDownloadSize);
+    return { data, filename, contentType };
+  }
+  submitLocalToolResult(runId, result, signal) {
+    return this.requestAPI(
+      "POST",
+      `/agent-runs/${encodeURIComponent(runId)}/local-tool-results`,
+      toWireLocalToolResult(result),
+      signal,
+      { retryOn401: false }
+    ).then(fromWireRun);
+  }
+  run(req, opts = {}, signal) {
+    return {
+      [Symbol.asyncIterator]: () => this.runGen(req, opts, signal)
+    };
+  }
+  runWithLocalTools(req, handlers, opts = {}, signal) {
+    return {
+      [Symbol.asyncIterator]: () => this.runWithLocalToolsGen(req, handlers, opts, signal)
+    };
+  }
+  async *runGen(req, opts, signal) {
+    const created = await this.create(req, signal);
+    yield* this.stream(created.runId, opts, signal);
+  }
+  async *runWithLocalToolsGen(req, handlers, opts, signal) {
+    let currentRunId = "";
+    for await (const event of this.run(req, opts, signal)) {
+      if (event.type === "run_started") {
+        currentRunId = event.runId;
+      }
+      if (opts.onEvent) await opts.onEvent(event);
+      let localToolTask;
+      if (event.type === "local_tool_request") {
+        if (currentRunId === "") {
+          throw new Error("local tool request arrived before run_started");
+        }
+        localToolTask = this.invokeLocalTool(currentRunId, event, handlers, opts.timeoutMs, signal).then(async (result) => {
+          await this.submitLocalToolResult(currentRunId, result, signal);
+        });
+      }
+      yield event;
+      if (localToolTask) await localToolTask;
+    }
+  }
+  async invokeLocalTool(runId, event, handlers, timeoutMs = 3e4, signal) {
+    const handler = handlers[event.name];
+    if (!handler) {
+      return {
+        requestId: event.requestId,
+        ok: false,
+        error: `local tool rejected: no handler for ${event.name}`
+      };
+    }
+    const ctl = new AbortController();
+    const timer = setTimeout(() => ctl.abort(), timeoutMs);
+    let parentAbort;
+    if (signal) {
+      if (signal.aborted) ctl.abort();
+      else {
+        parentAbort = () => ctl.abort();
+        signal.addEventListener("abort", parentAbort);
+      }
+    }
+    try {
+      const content = await handler(event.input, {
+        runId,
+        requestId: event.requestId,
+        name: event.name,
+        signal: ctl.signal
+      });
+      return { requestId: event.requestId, ok: true, content };
+    } catch (e) {
+      if (signal?.aborted) throw e;
+      const timedOut = ctl.signal.aborted;
+      return {
+        requestId: event.requestId,
+        ok: false,
+        error: timedOut ? `local tool timed out after ${timeoutMs}ms` : errorMessage(e)
+      };
+    } finally {
+      clearTimeout(timer);
+      if (parentAbort && signal) signal.removeEventListener("abort", parentAbort);
+    }
+  }
+  async *streamGen(runId, opts, signal) {
+    const resp = await this.requestRaw(
+      "GET",
+      `/agent-runs/${encodeURIComponent(runId)}/stream`,
+      null,
+      signal,
+      { retryOn401: true, accept: "text/event-stream" }
+    );
+    if (!resp.body) {
+      throw new Error("agent run stream: empty response body");
+    }
+    for await (const event of readAgentRunEvents(resp.body)) {
+      if (event.type === "error" && opts.throwOnError !== false) {
+        throw new AgentRunStreamError(event);
+      }
+      yield event;
+    }
+  }
+  async requestAPI(method, path, body, signal, opts) {
+    const resp = await this.requestRaw(method, path, body, signal, opts);
+    const text = await resp.text();
+    const result = JSON.parse(text);
+    const bizErr = apiResponseBusinessError(result);
+    if (bizErr) throw bizErr;
+    return result.data;
+  }
+  async requestRaw(method, path, body, signal, opts, retried = false) {
+    const token = await this.client.ensureToken(signal);
+    const url = this.client.apiURL(path);
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: opts.accept ?? "application/json"
+    };
+    let bodyStr;
+    if (body != null) {
+      bodyStr = typeof body === "string" ? body : JSON.stringify(body);
+      headers["Content-Type"] = "application/json";
+    }
+    const resp = await this.client.doRequest({ method, url, headers, body: bodyStr }, signal);
+    if (resp.status === 401 && opts.retryOn401 && !retried) {
+      try {
+        await resp.body?.cancel();
+      } catch {
+      }
+      await this.client.forceRefresh(signal);
+      return this.requestRaw(method, path, body, signal, opts, true);
+    }
+    if (resp.status < 200 || resp.status >= 300) {
+      const bodyBytes = resp.body ? await readLimited(resp.body, maxErrorBodySize) : new Uint8Array();
+      throw parseHTTPErrorWithHeader(resp.status, bodyBytes, resp.headers);
+    }
+    return resp;
+  }
+};
+function toWireCreateRequest(req) {
+  return {
+    app_id: req.appId,
+    mode: req.mode,
+    session_id: req.sessionId,
+    input: req.input,
+    messages: req.messages,
+    model: req.model,
+    active_skill_ids: req.activeSkillIds,
+    knowledge_base_ids: req.knowledgeBaseIds,
+    metadata: req.metadata,
+    local_context_policy: req.localContextPolicy ? {
+      enabled: req.localContextPolicy.enabled,
+      readonly: req.localContextPolicy.readonly,
+      max_bytes: req.localContextPolicy.maxBytes,
+      allowed_tools: req.localContextPolicy.allowedTools
+    } : void 0,
+    artifact_policy: req.artifactPolicy ? {
+      enabled: req.artifactPolicy.enabled,
+      max_files: req.artifactPolicy.maxFiles
+    } : void 0
+  };
+}
+function toWireLocalToolResult(result) {
+  return {
+    request_id: result.requestId,
+    ok: result.ok,
+    content: result.content,
+    error: result.error
+  };
+}
+function fromWireCreateResponse(resp) {
+  return {
+    runId: resp.run_id ?? "",
+    sessionId: resp.session_id ?? "",
+    status: toStatus(resp.status)
+  };
+}
+function fromWireRun(resp) {
+  return {
+    runId: resp.run_id ?? "",
+    sessionId: resp.session_id ?? "",
+    appId: resp.app_id,
+    mode: resp.mode,
+    status: toStatus(resp.status),
+    createdAt: resp.created_at,
+    startedAt: resp.started_at,
+    completedAt: resp.completed_at,
+    error: normalizeError(resp.error),
+    metadata: resp.metadata
+  };
+}
+function fromWireArtifact(resp) {
+  return {
+    id: resp.id ?? resp.artifact_id ?? "",
+    filename: resp.filename ?? resp.name ?? resp.id ?? resp.artifact_id ?? "artifact",
+    contentType: resp.content_type ?? resp.mime_type,
+    size: typeof resp.size === "number" ? resp.size : void 0,
+    type: resp.type,
+    metadata: resp.metadata
+  };
+}
+async function* readAgentRunEvents(body) {
+  let eventName = "";
+  let dataLines = [];
+  const flush = () => {
+    if (dataLines.length === 0) return null;
+    const data = dataLines.join("\n");
+    dataLines = [];
+    if (data === "[DONE]") return null;
+    return parseAgentRunEvent(eventName, data);
+  };
+  for await (const line of iterSSELines(body)) {
+    if (line === "") {
+      const event2 = flush();
+      eventName = "";
+      if (event2) yield event2;
+      continue;
+    }
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("event:")) {
+      eventName = line.slice("event:".length).trim();
+      continue;
+    }
+    if (line.startsWith("data:")) {
+      dataLines.push(line.slice("data:".length).trimStart());
+    }
+  }
+  const event = flush();
+  if (event) yield event;
+}
+function parseAgentRunEvent(eventName, data) {
+  const payload = JSON.parse(data);
+  const obj = isRecord(payload) ? payload : { type: eventName, data: payload };
+  const type = stringField(obj, "type") || eventName;
+  switch (type) {
+    case "run_started":
+      return {
+        type: "run_started",
+        runId: stringField(obj, "run_id", "runId"),
+        sessionId: stringField(obj, "session_id", "sessionId")
+      };
+    case "status":
+      return {
+        type: "status",
+        status: stringField(obj, "status"),
+        message: optionalStringField(obj, "message")
+      };
+    case "text_delta":
+      return { type: "text_delta", text: stringField(obj, "text") };
+    case "reasoning_delta":
+      return { type: "reasoning_delta", text: stringField(obj, "text") };
+    case "tool_call":
+      return {
+        type: "tool_call",
+        id: stringField(obj, "id"),
+        name: stringField(obj, "name"),
+        input: obj.input
+      };
+    case "tool_result":
+      return {
+        type: "tool_result",
+        id: stringField(obj, "id"),
+        name: optionalStringField(obj, "name"),
+        result: obj.result,
+        error: optionalStringField(obj, "error")
+      };
+    case "local_tool_request":
+      return {
+        type: "local_tool_request",
+        requestId: stringField(obj, "request_id", "requestId"),
+        name: stringField(obj, "name"),
+        input: obj.input
+      };
+    case "artifact":
+      return {
+        type: "artifact",
+        artifact: fromWireArtifact(isRecord(obj.artifact) ? obj.artifact : obj)
+      };
+    case "sources":
+      return { type: "sources", sources: obj.sources };
+    case "usage":
+      return {
+        type: "usage",
+        usage: normalizeUsage(isRecord(obj.usage) ? obj.usage : obj)
+      };
+    case "settle":
+      return {
+        type: "settle",
+        settlement: normalizeSettlement(isRecord(obj.settlement) ? obj.settlement : obj)
+      };
+    case "error":
+      return { type: "error", error: normalizeError(obj.error) ?? normalizeError(obj) };
+    case "done":
+      return {
+        type: "done",
+        runId: stringField(obj, "run_id", "runId"),
+        status: stringField(obj, "status")
+      };
+    default:
+      return {
+        type: "error",
+        error: {
+          code: "unknown_event",
+          message: `unknown agent run event: ${type}`,
+          raw: obj
+        }
+      };
+  }
+}
+function normalizeUsage(value) {
+  return {
+    ...value,
+    inputTokens: numberField(value, "input_tokens", "inputTokens"),
+    outputTokens: numberField(value, "output_tokens", "outputTokens"),
+    totalTokens: numberField(value, "total_tokens", "totalTokens"),
+    cacheReadTokens: numberField(value, "cache_read_tokens", "cacheReadTokens"),
+    cacheCreateTokens: numberField(value, "cache_create_tokens", "cacheCreateTokens"),
+    exact: booleanField(value, "exact"),
+    source: optionalStringField(value, "source")
+  };
+}
+function normalizeSettlement(value) {
+  return {
+    ...value,
+    requestId: optionalStringField(value, "request_id", "requestId"),
+    status: optionalStringField(value, "status"),
+    consumeStatus: optionalStringField(value, "consume_status", "consumeStatus"),
+    inputTokens: numberField(value, "input_tokens", "inputTokens"),
+    outputTokens: numberField(value, "output_tokens", "outputTokens"),
+    totalTokens: numberField(value, "total_tokens", "totalTokens"),
+    cacheReadTokens: numberField(value, "cache_read_tokens", "cacheReadTokens"),
+    cacheCreateTokens: numberField(value, "cache_create_tokens", "cacheCreateTokens"),
+    tokenRemaining: numberField(value, "token_remaining", "tokenRemaining"),
+    callRemaining: numberField(value, "call_remaining", "callRemaining"),
+    retryQueued: booleanField(value, "retry_queued", "retryQueued"),
+    exact: booleanField(value, "exact")
+  };
+}
+function normalizeError(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") return { message: value, raw: value };
+  if (!isRecord(value)) return { message: String(value), raw: value };
+  return {
+    code: optionalStringField(value, "code", "error_code", "errorCode"),
+    message: stringField(value, "message", "error") || "agent run failed",
+    stage: optionalStringField(value, "stage"),
+    retryable: typeof value.retryable === "boolean" ? value.retryable : void 0,
+    raw: value
+  };
+}
+function toStatus(status) {
+  switch (status) {
+    case "running":
+    case "completed":
+    case "failed":
+    case "cancelled":
+      return status;
+    default:
+      return "queued";
+  }
+}
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function stringField(obj, ...keys) {
+  for (const key of keys) {
+    const value = obj[key];
+    if (typeof value === "string") return value;
+  }
+  return "";
+}
+function optionalStringField(obj, ...keys) {
+  const value = stringField(obj, ...keys);
+  return value === "" ? void 0 : value;
+}
+function numberField(obj, ...keys) {
+  for (const key of keys) {
+    const value = obj[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function booleanField(obj, ...keys) {
+  for (const key of keys) {
+    const value = obj[key];
+    if (typeof value === "boolean") return value;
+  }
+  return void 0;
+}
+function filenameFromContentDisposition(value) {
+  if (!value) return null;
+  const utf8 = /filename\*=UTF-8''([^;]+)/i.exec(value);
+  if (utf8?.[1]) {
+    try {
+      return decodeURIComponent(utf8[1]);
+    } catch {
+      return utf8[1];
+    }
+  }
+  const plain = /filename="?([^";]+)"?/i.exec(value);
+  return plain?.[1] ?? null;
+}
+function errorMessage(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
+// src/index.ts
+init_betas();
+
 // src/client/entitlements.ts
 Client.prototype.getBalance = async function(signal) {
   const resp = await this.doJSON(
@@ -4078,6 +4576,6 @@ Client.prototype.getBugReport = async function(bugID, signal) {
   return resp.data;
 };
 
-export { AnthropicAdapter, BucketClassCommercial, BucketClassGeneric, BusinessError, Client, DefaultRetryPolicy, ErrAuthDenied, ErrBrowserOpen, ErrDiscovery, ErrRegistration, ErrSSLProxy, ErrTimeout, ErrTokenExchange, EventAuthURL, EventComplete, EventError, FileTokenStore, FilterStatusAdminBypass, FilterStatusDisabledByFlag, FilterStatusFallbackMissingUser, FilterStatusFallbackNoBuckets, FilterStatusFallbackTkdistError, FilterStatusFallbackTkdistSkew, FilterStatusInternalBypass, FilterStatusOK, FilterStatusUnknown, HTTPError, InMemoryTokenStore, LocalStorageTokenStore, ModelNotFoundError, NetworkError, OpenAIAdapter, OrderTerminalError, ProviderFormat, RateLimitError, ScopeAI, ScopeAccount, ScopeEntitlements, ScopeModels, ScopeModelsChat, ScopeProfile, ScopeSkillStore, ScopeSkills, ScopeTokenPackages, ScopeTools, ScopeToolsExecute, ScopeWallet, ScopeWalletReadonly, ServerToolTypeWebSearch, StreamError, ThinkingHigh, ThinkingHighMinMaxTokens, ThinkingMax, ThinkingMaxFallbackMaxTokens, ThinkingOff, allScopes, anthropicResponseTextContent, anthropicResponseThinkingContent, anthropicResponseToolUseBlocks, apiResponseBusinessError, apiResponseGetMessage, authorize, bucketInfoIsCommercial, bucketRowIsCommercial, buildBetas, commerceScopes, computeBackoff, defaultRetryable, defaultSafeToRetry, discover, effectivePolicy, exchangeCode, extractAnthropicBlockMeta, fileLockDefaults, getAdapter, getAdapterForModel, isSSLError, modelScopes, newFileTokenStore, newThinkingConfig, newTokenSet, newWebSearchTool, parseNotificationEvent, parseSettlement, parseSourcesEvent, refreshToken, register, revokeToken, sanitize_exports as sanitize, skillScopes, tokenSetIsExpired, uniqueMerge };
+export { AgentRunStreamError, AgentRunsClient, AnthropicAdapter, BucketClassCommercial, BucketClassGeneric, BusinessError, Client, DefaultRetryPolicy, ErrAuthDenied, ErrBrowserOpen, ErrDiscovery, ErrRegistration, ErrSSLProxy, ErrTimeout, ErrTokenExchange, EventAuthURL, EventComplete, EventError, FileTokenStore, FilterStatusAdminBypass, FilterStatusDisabledByFlag, FilterStatusFallbackMissingUser, FilterStatusFallbackNoBuckets, FilterStatusFallbackTkdistError, FilterStatusFallbackTkdistSkew, FilterStatusInternalBypass, FilterStatusOK, FilterStatusUnknown, HTTPError, InMemoryTokenStore, LocalStorageTokenStore, ModelNotFoundError, NetworkError, OpenAIAdapter, OrderTerminalError, ProviderFormat, RateLimitError, ScopeAI, ScopeAccount, ScopeEntitlements, ScopeModels, ScopeModelsChat, ScopeProfile, ScopeSkillStore, ScopeSkills, ScopeTokenPackages, ScopeTools, ScopeToolsExecute, ScopeWallet, ScopeWalletReadonly, ServerToolTypeWebSearch, StreamError, ThinkingHigh, ThinkingHighMinMaxTokens, ThinkingMax, ThinkingMaxFallbackMaxTokens, ThinkingOff, allScopes, anthropicResponseTextContent, anthropicResponseThinkingContent, anthropicResponseToolUseBlocks, apiResponseBusinessError, apiResponseGetMessage, authorize, bucketInfoIsCommercial, bucketRowIsCommercial, buildBetas, commerceScopes, computeBackoff, defaultRetryable, defaultSafeToRetry, discover, effectivePolicy, exchangeCode, extractAnthropicBlockMeta, fileLockDefaults, getAdapter, getAdapterForModel, isSSLError, modelScopes, newFileTokenStore, newThinkingConfig, newTokenSet, newWebSearchTool, parseNotificationEvent, parseSettlement, parseSourcesEvent, refreshToken, register, revokeToken, sanitize_exports as sanitize, skillScopes, tokenSetIsExpired, uniqueMerge };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map