@cadraos/sdk 0.3.14-p46.4 → 0.3.15

package/dist/chat/index.js

@@ -68,6 +68,14 @@ var CadraError = class extends Error {
   details;
   /** Request ID from server (for debugging) */
   requestId;
+  /**
+   * The server's own `error.code` exactly as sent on the wire (e.g.
+   * `FUNCTION_NOT_PUBLISHED`, `DUPLICATE_REQUEST`, `VARIABLE_TYPE`).
+   * Populated by `parseApiError` for EVERY status. `code` keeps its historic
+   * per-class values (`conflict`, `server_error`, `validation_error`, …) for
+   * compatibility; branch on `serverCode` when you need the precise reason.
+   */
+  serverCode;
   constructor(message, code, status, details, requestId) {
     super(message);
     this.name = "CadraError";
@@ -145,6 +153,12 @@ function parseApiError(status, body, requestId) {
   const message = errorBody?.error?.message ?? "An error occurred";
   const code = errorBody?.error?.code ?? "unknown_error";
   const details = errorBody?.error?.details;
+  const serverCode = typeof errorBody?.error?.code === "string" ? errorBody.error.code : void 0;
+  const error = buildApiError(status, message, code, details, requestId);
+  if (serverCode !== void 0) error.serverCode = serverCode;
+  return error;
+}
+function buildApiError(status, message, code, details, requestId) {
   switch (status) {
     case 400:
     case 422: {
@@ -180,6 +194,42 @@ function parseApiError(status, body, requestId) {
   }
 }
 
+// src/errors/ai-function-errors.ts
+var AiFunctionDuplicateError = class extends ConflictError {
+  /** The existing run's execution id. */
+  executionId;
+  /** The existing run's status (`running`, a terminal status, or `abandoned`). */
+  runStatus;
+  constructor(message, details, requestId) {
+    super(message, details, requestId);
+    this.name = "AiFunctionDuplicateError";
+    this.serverCode = "DUPLICATE_REQUEST";
+    this.executionId = typeof details?.executionId === "string" ? details.executionId : void 0;
+    this.runStatus = typeof details?.status === "string" ? details.status : void 0;
+  }
+};
+var AiFunctionChargedError = class extends CadraError {
+  constructor(source) {
+    super(source.message, source.code, source.status, source.details, source.requestId);
+    this.name = "AiFunctionChargedError";
+    this.serverCode = source.serverCode;
+  }
+};
+var AiFunctionParameterError = class extends ValidationError {
+  functionKey;
+  issues;
+  constructor(functionKey, issues) {
+    super(
+      `Invalid parameters for AI function "${functionKey}": ` + issues.map((i) => `${i.name} (${i.code})`).join(", "),
+      issues.map((i) => ({ field: i.name, message: i.code })),
+      { functionKey, issues }
+    );
+    this.name = "AiFunctionParameterError";
+    this.functionKey = functionKey;
+    this.issues = issues;
+  }
+};
+
 // src/utils/retry.ts
 var DEFAULT_RETRY_CONFIG = {
   maxRetries: 3,
@@ -244,6 +294,10 @@ var HttpClient = class {
   constructor(config) {
     this.config = config;
   }
+  /** The client-wide request timeout (ms) this client was configured with. */
+  get timeoutMs() {
+    return this.config.timeout;
+  }
   /**
    * Get authorization header value
    */
@@ -298,7 +352,8 @@ var HttpClient = class {
         headers["Idempotency-Key"] = options.idempotencyKey;
       }
       const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+      const timeoutMs = options.timeoutMs ?? this.config.timeout;
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
       try {
         const doFetch = this.config.fetch ?? fetch;
         const response = await doFetch(url, {
@@ -334,7 +389,7 @@ var HttpClient = class {
       } catch (error) {
         clearTimeout(timeoutId);
         if (error instanceof Error && error.name === "AbortError") {
-          throw new TimeoutError(`Request timed out after ${this.config.timeout}ms`);
+          throw new TimeoutError(`Request timed out after ${options.timeoutMs ?? this.config.timeout}ms`);
         }
         if (error instanceof TypeError && error.message.includes("fetch")) {
           throw new NetworkError(`Network error: ${error.message}`);
@@ -366,7 +421,8 @@ var HttpClient = class {
       path,
       body,
       idempotencyKey: options?.idempotencyKey,
-      skipRetry: options?.skipRetry
+      skipRetry: options?.skipRetry,
+      timeoutMs: options?.timeoutMs
     });
   }
   /**
@@ -1125,6 +1181,10 @@ var ExecutionStreamControllerImpl = class {
           toolName,
           result: data.result,
           durationMs: data.durationMs ?? 0,
+          // CAD-243: pass the producer's failure verdict through.
+          ...data.isError === true ? { isError: true } : {},
+          ...typeof data.status === "string" ? { status: data.status } : {},
+          ...typeof data.error === "string" ? { error: data.error } : {},
           forwardedFrom: event.data._forwardedFrom,
           // CAD-87 S1-001 EventIdentity → (execId, seq) reducer dedup (S1-003).
           sourceExecutionId: data.sourceExecutionId ?? data.executionId,
@@ -3363,6 +3423,156 @@ var RemoteRunnersAPI = class extends BaseResourceAPI {
   }
 };
 
+// src/resources/ai-functions.ts
+var AI_FUNCTION_RUN_TIMEOUT_MS = 31e4;
+var AI_FUNCTION_DESCRIPTOR_TTL_MS = 6e4;
+function checkAiFunctionParameters(parameters, variables) {
+  const issues = [];
+  const declared = /* @__PURE__ */ new Set();
+  for (const p of parameters) {
+    declared.add(p.name);
+    const has = Object.prototype.hasOwnProperty.call(variables, p.name);
+    const value = has ? variables[p.name] : void 0;
+    if (value === void 0 || value === null) {
+      if (p.required) issues.push({ name: p.name, code: "missing" });
+      continue;
+    }
+    switch (p.type) {
+      case "number":
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+          issues.push({ name: p.name, code: "type" });
+        }
+        break;
+      case "boolean":
+        if (typeof value !== "boolean") issues.push({ name: p.name, code: "type" });
+        break;
+      case "enum":
+        if (typeof value !== "string") issues.push({ name: p.name, code: "type" });
+        else if (p.options && !p.options.includes(value)) {
+          issues.push({ name: p.name, code: "option" });
+        }
+        break;
+      case "string":
+      case "text":
+        if (typeof value !== "string") issues.push({ name: p.name, code: "type" });
+        else if (typeof p.maxLength === "number" && value.length > p.maxLength) {
+          issues.push({ name: p.name, code: "too_long" });
+        }
+        break;
+      case "image":
+        if (typeof value !== "string") issues.push({ name: p.name, code: "type" });
+        break;
+    }
+  }
+  for (const name of Object.keys(variables)) {
+    if (!declared.has(name)) issues.push({ name, code: "unknown" });
+  }
+  return issues;
+}
+var AiFunctionsAPI = class extends BaseResourceAPI {
+  descriptorCache = /* @__PURE__ */ new Map();
+  constructor(http) {
+    super(http, "/api/v1/ai-functions");
+  }
+  /**
+   * List the functions this org can call — the index (D27a). Each entry carries
+   * the live version's typed parameters; never prompt text.
+   */
+  async list() {
+    const data = await this.httpGet("");
+    const functions = Array.isArray(data) ? data : data?.functions ?? [];
+    for (const d of functions) this.cacheDescriptor(d);
+    return functions;
+  }
+  /**
+   * Get one function's descriptor by key (D27a).
+   * `NotFoundError` (`FUNCTION_NOT_FOUND`) / `ConflictError` (`FUNCTION_NOT_PUBLISHED`).
+   */
+  async get(functionKey) {
+    const data = await this.httpGet(
+      `/${encodeURIComponent(functionKey)}`
+    );
+    const descriptor = data && typeof data === "object" && "function" in data && !("functionKey" in data) ? data.function : data;
+    this.cacheDescriptor(descriptor, functionKey);
+    return descriptor;
+  }
+  /**
+   * Read one of this org's own runs (safe projection, §6.5).
+   */
+  async getRun(executionId) {
+    return this.httpGet(`/runs/${encodeURIComponent(executionId)}`);
+  }
+  /** Forget cached descriptors (one key, or all). */
+  clearDescriptorCache(functionKey) {
+    if (functionKey) this.descriptorCache.delete(functionKey);
+    else this.descriptorCache.clear();
+  }
+  async run(refOrKey, parametersOrOptions, shorthandOpts) {
+    let ref;
+    let options;
+    if (typeof refOrKey === "string") {
+      ref = { functionKey: refOrKey };
+      options = { ...shorthandOpts ?? {}, variables: parametersOrOptions };
+    } else {
+      ref = refOrKey;
+      options = parametersOrOptions;
+    }
+    const variables = options.variables ?? {};
+    const functionKey = "functionKey" in ref ? ref.functionKey : void 0;
+    const shouldCheck = functionKey !== void 0 && options.version === void 0 && options.validate !== false;
+    if (shouldCheck) {
+      const descriptor = await this.getCachedDescriptor(functionKey);
+      const issues = checkAiFunctionParameters(descriptor.parameters, variables);
+      if (issues.length > 0) {
+        throw new AiFunctionParameterError(functionKey, issues);
+      }
+    }
+    const body = {
+      ref,
+      variables,
+      version: options.version,
+      idempotencyKey: options.idempotencyKey ?? generateExecutionId(),
+      params: options.params
+    };
+    try {
+      return await this.httpPost("/run", body, {
+        skipRetry: true,
+        timeoutMs: Math.max(AI_FUNCTION_RUN_TIMEOUT_MS, this.http.timeoutMs ?? 0)
+      });
+    } catch (error) {
+      throw this.mapRunError(error, functionKey);
+    }
+  }
+  // ── internals ──────────────────────────────────────────────────────────────
+  cacheDescriptor(descriptor, key) {
+    if (!descriptor || typeof descriptor !== "object") return;
+    const cacheKey = key ?? descriptor.functionKey;
+    if (!cacheKey) return;
+    this.descriptorCache.set(cacheKey, {
+      descriptor,
+      expiresAt: Date.now() + AI_FUNCTION_DESCRIPTOR_TTL_MS
+    });
+  }
+  async getCachedDescriptor(functionKey) {
+    const hit = this.descriptorCache.get(functionKey);
+    if (hit && hit.expiresAt > Date.now()) return hit.descriptor;
+    return this.get(functionKey);
+  }
+  mapRunError(error, functionKey) {
+    if (!(error instanceof CadraError)) return error;
+    if (error.serverCode === "DUPLICATE_REQUEST") {
+      return new AiFunctionDuplicateError(error.message, error.details, error.requestId);
+    }
+    if (error.details?.charged === true) {
+      return new AiFunctionChargedError(error);
+    }
+    if (functionKey && error.serverCode?.startsWith("VARIABLE_")) {
+      this.descriptorCache.delete(functionKey);
+    }
+    return error;
+  }
+};
+
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.cadraos.com";
 var DEFAULT_TIMEOUT = 3e4;
@@ -3409,6 +3619,10 @@ var CadraClient = class {
    * Remote runner operations (list)
    */
   remoteRunners;
+  /**
+   * AI function operations (list, get, run, getRun) — p93
+   */
+  aiFunctions;
   /**
    * Create a new AI SaaS client
    *
@@ -3498,6 +3712,7 @@ var CadraClient = class {
     this.kanban = new KanbanAPI(this.httpClient, getStreamConfig);
     this.remoteAgents = new RemoteAgentsAPI(this.httpClient, getStreamConfig);
     this.remoteRunners = new RemoteRunnersAPI(this.httpClient);
+    this.aiFunctions = new AiFunctionsAPI(this.httpClient);
   }
   /**
    * Validate client options
@@ -4187,6 +4402,32 @@ function useExecutionStream(options) {
   };
 }
 
+// src/chat/utils/toolOutcome.ts
+var MAX_ERROR_CHARS = 500;
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function errorFrom(value) {
+  if (typeof value === "string" && value.trim()) return value;
+  const rec = asRecord(value);
+  if (rec && typeof rec.message === "string" && rec.message.trim()) return rec.message;
+  return void 0;
+}
+function isFailurePayload(result) {
+  const rec = asRecord(result);
+  if (!rec) return false;
+  return rec.success === false || rec.isError === true;
+}
+function cap(text) {
+  return text.length > MAX_ERROR_CHARS ? `${text.slice(0, MAX_ERROR_CHARS)}\u2026` : text;
+}
+function resolveToolOutcome(input) {
+  const failed = input.isError === true || input.status === "failed" || input.success === false || input.payloadFailure === true || isFailurePayload(input.result);
+  if (!failed) return { status: "completed" };
+  const error = errorFrom(input.error) ?? errorFrom(asRecord(input.result)?.error) ?? "Tool call failed";
+  return { status: "failed", error: cap(error) };
+}
+
 // src/chat/hooks/history-cache.ts
 var DEFAULT_HISTORY_STALE_MS = 1e4;
 var cache = /* @__PURE__ */ new Map();
@@ -4362,9 +4603,10 @@ function applyEventInner(state, event) {
       if (tc) {
         toolCalls.set(event.id, {
           ...tc,
-          status: "completed",
+          status: event.status ?? "completed",
           result: event.result,
-          durationMs: event.durationMs
+          durationMs: event.durationMs,
+          ...event.error !== void 0 ? { error: event.error } : {}
         });
         return { ...state, toolCalls };
       }
@@ -4373,8 +4615,9 @@ function applyEventInner(state, event) {
         name: event.toolName ?? "unknown",
         args: {},
         result: event.result,
-        status: "completed",
-        durationMs: event.durationMs
+        status: event.status ?? "completed",
+        durationMs: event.durationMs,
+        ...event.error !== void 0 ? { error: event.error } : {}
       });
       if (state.seenToolBlockIds.has(event.id)) {
         return { ...state, toolCalls };
@@ -4624,8 +4867,16 @@ function useAgentChat(options) {
     const streamMsgId = streamingMessageIdRef.current;
     setMessages((prev) => {
       const resolvedContent = streamingContentRef.current || finalOutput || "";
+      const streamIdx = prev.findIndex((msg) => msg.id === streamMsgId);
+      let turnStart = 0;
+      for (let i = streamIdx - 1; i >= 0; i--) {
+        if (prev[i].role === "user") {
+          turnStart = i + 1;
+          break;
+        }
+      }
       const duplicateExists = resolvedContent && prev.some(
-        (msg) => msg.id !== streamMsgId && msg.role === "assistant" && !msg.isStreaming && msg.content === resolvedContent
+        (msg, idx) => idx >= turnStart && msg.id !== streamMsgId && msg.role === "assistant" && !msg.isStreaming && msg.content === resolvedContent
       );
       if (duplicateExists) {
         return prev.filter((msg) => msg.id !== streamMsgId);
@@ -4746,6 +4997,17 @@ function useAgentChat(options) {
           const resultToolCallId = log.metadata?.toolCallId;
           const result = log.metadata?.output;
           const durationMs = log.durationMs;
+          const outcome = resolveToolOutcome({
+            result,
+            success: log.metadata?.success,
+            payloadFailure: log.metadata?.payloadFailure,
+            isError: log.metadata?.isError,
+            error: log.metadata?.error
+          });
+          const outcomeFields = {
+            status: outcome.status,
+            ...outcome.error ? { error: outcome.error } : {}
+          };
           let matchedToolCall = resultToolCallId ? pendingToolCallsRef.current.get(resultToolCallId) : void 0;
           if (!matchedToolCall) {
             for (const [, tc] of pendingToolCallsRef.current) {
@@ -4759,7 +5021,7 @@ function useAgentChat(options) {
             const completedToolCall = {
               ...matchedToolCall,
               result,
-              status: "completed",
+              ...outcomeFields,
               durationMs
             };
             updateToolCall(completedToolCall);
@@ -4770,7 +5032,7 @@ function useAgentChat(options) {
               name: resultToolName || "unknown",
               args: {},
               result,
-              status: "completed",
+              ...outcomeFields,
               durationMs
             };
             updateToolCall(lateToolCall);
@@ -4781,7 +5043,8 @@ function useAgentChat(options) {
               id: resultToolCallId,
               toolName: resultToolName,
               result,
-              durationMs
+              durationMs,
+              ...outcomeFields
             });
             firedToolResultsRef.current.add(resultToolCallId);
           }
@@ -4891,6 +5154,17 @@ function useAgentChat(options) {
           const resultToolCallId = log.metadata?.toolCallId;
           const result = log.metadata?.output;
           const durationMs = log.durationMs;
+          const outcome = resolveToolOutcome({
+            result,
+            success: log.metadata?.success,
+            payloadFailure: log.metadata?.payloadFailure,
+            isError: log.metadata?.isError,
+            error: log.metadata?.error
+          });
+          const outcomeFields = {
+            status: outcome.status,
+            ...outcome.error ? { error: outcome.error } : {}
+          };
           let matchedToolCall = resultToolCallId ? pendingToolCallsRef.current.get(resultToolCallId) : void 0;
           if (!matchedToolCall) {
             for (const [, tc] of pendingToolCallsRef.current) {
@@ -4904,7 +5178,7 @@ function useAgentChat(options) {
             const completedToolCall = {
               ...matchedToolCall,
               result,
-              status: "completed",
+              ...outcomeFields,
               durationMs
             };
             updateToolCall(completedToolCall);
@@ -4915,7 +5189,7 @@ function useAgentChat(options) {
               name: resultToolName || "unknown",
               args: {},
               result,
-              status: "completed",
+              ...outcomeFields,
               durationMs
             };
             updateToolCall(lateToolCall);
@@ -4926,7 +5200,8 @@ function useAgentChat(options) {
               id: resultToolCallId,
               toolName: resultToolName,
               result,
-              durationMs
+              durationMs,
+              ...outcomeFields
             });
           }
           if (resultToolCallId) {
@@ -5175,12 +5450,22 @@ function useAgentChat(options) {
         if (SILENT_TOOL_NAMES.has(toolName) || isUuidLikeToolName(toolName)) return;
         if (firedToolResultsRef.current.has(toolCallId)) return;
         const existing = pendingToolCallsRef.current.get(toolCallId);
-        if (existing && existing.status === "completed") return;
+        if (existing && (existing.status === "completed" || existing.status === "failed")) return;
+        const outcome = resolveToolOutcome({
+          result: data.result,
+          isError: data.isError,
+          status: data.status,
+          error: data.error
+        });
+        const outcomeFields = {
+          status: outcome.status,
+          ...outcome.error ? { error: outcome.error } : {}
+        };
         if (existing) {
           const completedToolCall = {
             ...existing,
             result: data.result,
-            status: "completed",
+            ...outcomeFields,
             durationMs: data.durationMs
           };
           updateToolCall(completedToolCall);
@@ -5191,7 +5476,7 @@ function useAgentChat(options) {
             name: toolName,
             args: {},
             result: data.result,
-            status: "completed",
+            ...outcomeFields,
             durationMs: data.durationMs
           };
           updateToolCall(lateToolCall);
@@ -5202,6 +5487,7 @@ function useAgentChat(options) {
           toolName,
           result: data.result,
           durationMs: data.durationMs,
+          ...outcomeFields,
           // CAD-87 S1-003: (execId, seq) reducer dedup for replayed events.
           execId: data.sourceExecutionId,
           seq: data.seq