@acosmi/sdk-ts 1.0.2 → 1.2.0

package/dist/browser/index.mjs

@@ -1013,6 +1013,45 @@ var init_adapters = __esm({
 
 // src/index.ts
 init_types();
+
+// src/model-helpers.ts
+function modelSupportsInputModality(model, modality) {
+  if (!model) return false;
+  const mods = model.inputModalities;
+  if (!Array.isArray(mods)) return false;
+  return mods.includes(modality);
+}
+function modelSupportsImageInput(model) {
+  return modelSupportsInputModality(model, "image");
+}
+function findFirstModelByInputModality(models, modality) {
+  if (!Array.isArray(models)) return null;
+  for (const m of models) {
+    if (!m) continue;
+    if (m.isEnabled === false) continue;
+    if (!modelSupportsInputModality(m, modality)) continue;
+    return m;
+  }
+  return null;
+}
+function findDesktopVisualUnderstandingModel(models) {
+  if (!Array.isArray(models)) return null;
+  const candidates = [];
+  for (const m of models) {
+    if (!m) continue;
+    if (m.isEnabled === false) continue;
+    if (m.capabilities?.supports_desktop_visual_understanding !== true) continue;
+    if (!modelSupportsInputModality(m, "image")) continue;
+    candidates.push(m);
+  }
+  if (candidates.length === 0) return null;
+  for (const m of candidates) {
+    if (m.isDefault === true) return m;
+  }
+  return candidates[0];
+}
+
+// src/index.ts
 init_adapters();
 
 // src/auth.ts
@@ -1972,8 +2011,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();
@@ -2571,14 +2627,15 @@ var Client = class _Client {
       null,
       signal
     );
-    this.modelCache = result.data;
+    const normalized = normalizeInputModalities(result.data);
+    this.modelCache = normalized;
     this.modelCacheTimeMs = Date.now();
     let status = "";
     if (headers) {
       const h = headers.get("X-Entitlement-Filter-Status");
       if (h) status = h;
     }
-    return { models: result.data, status };
+    return { models: normalized, status };
   }
   /** 查询当前用户账户级权益总览 (v0.19+) */
   async getQuotaSummary(signal) {
@@ -3211,9 +3268,24 @@ function zeroModelCapabilities() {
     supports_token_efficient: false,
     supports_redact_thinking: false,
     max_input_tokens: 0,
-    max_output_tokens: 0
+    max_output_tokens: 0,
+    supports_desktop_visual_understanding: false
   };
 }
+function normalizeInputModalities(models) {
+  if (!Array.isArray(models)) return models;
+  for (const m of models) {
+    if (!m || typeof m !== "object") continue;
+    if (Array.isArray(m.inputModalities)) continue;
+    const snake = m.input_modalities;
+    if (Array.isArray(snake)) {
+      m.inputModalities = snake.filter(
+        (v) => v === "text" || v === "image"
+      );
+    }
+  }
+  return models;
+}
 function withRequestTimeout(ms, parent) {
   const ctl = new AbortController();
   const timer = setTimeout(() => ctl.abort(), ms);
@@ -3254,6 +3326,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 +4631,6 @@ Client.prototype.getBugReport = async function(bugID, signal) {
   return resp.data;
 };
 
-export { AnthropicAdapter, BucketClassCommercial, BucketClassGeneric, BusinessError, Client, LocalStorageTokenStore as DefaultBrowserTokenStore, 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, LocalStorageTokenStore as DefaultBrowserTokenStore, 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, findDesktopVisualUnderstandingModel, findFirstModelByInputModality, getAdapter, getAdapterForModel, isSSLError, modelScopes, modelSupportsImageInput, modelSupportsInputModality, 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