@runtypelabs/sdk 2.1.1 → 3.0.0

package/dist/index.mjs

@@ -11,9 +11,12 @@ var __export = (target, all) => {
 // src/stream-utils.ts
 var stream_utils_exports = {};
 __export(stream_utils_exports, {
+  flowErrorMessage: () => flowErrorMessage,
   parseFinalBuffer: () => parseFinalBuffer,
   parseSSEChunk: () => parseSSEChunk,
   processStream: () => processStream,
+  stepDeltaText: () => stepDeltaText,
+  stepDisplayName: () => stepDisplayName,
   streamEvents: () => streamEvents
 });
 function parseSSEChunk(chunk, buffer) {
@@ -134,7 +137,7 @@ async function processStream(response, callbacks = {}) {
         try {
           const event = JSON.parse(eventStr);
           handleEvent(event, callbacks, results, flowSummary);
-        } catch (parseError) {
+        } catch {
           console.warn("Failed to parse SSE event:", eventStr);
         }
       }
@@ -144,7 +147,7 @@ async function processStream(response, callbacks = {}) {
       try {
         const event = JSON.parse(finalEvent);
         handleEvent(event, callbacks, results, flowSummary);
-      } catch (parseError) {
+      } catch {
       }
     }
   } catch (error) {
@@ -166,6 +169,15 @@ async function processStream(response, callbacks = {}) {
     success: flowSummary.success ?? true
   };
 }
+function stepDeltaText(event) {
+  return event.text ?? event.delta ?? "";
+}
+function stepDisplayName(event) {
+  return event.name ?? event.stepName ?? "";
+}
+function flowErrorMessage(event) {
+  return typeof event.error === "string" ? event.error : JSON.stringify(event.error);
+}
 function handleEvent(event, callbacks, results, summary) {
   switch (event.type) {
     case "flow_start":
@@ -178,24 +190,26 @@ function handleEvent(event, callbacks, results, summary) {
       callbacks.onStepStart?.(event);
       break;
     case "step_delta":
-      callbacks.onStepDelta?.(event.text, event);
+      callbacks.onStepDelta?.(stepDeltaText(event), event);
       break;
-    case "step_complete":
-      results.set(event.name, event.result);
+    case "step_complete": {
+      results.set(stepDisplayName(event), event.result);
       callbacks.onStepComplete?.(event.result, event);
       break;
+    }
     case "flow_complete":
       summary.totalSteps = event.totalSteps;
       summary.successfulSteps = event.successfulSteps;
       summary.failedSteps = event.failedSteps;
       summary.executionTime = event.executionTime;
-      summary.success = event.failedSteps === 0;
+      summary.success = event.success ?? (event.failedSteps ?? 0) === 0;
       callbacks.onFlowComplete?.(event);
       break;
-    case "flow_error":
+    case "flow_error": {
       summary.success = false;
-      callbacks.onError?.(new Error(event.error));
+      callbacks.onError?.(new Error(flowErrorMessage(event)));
       break;
+    }
     case "flow_await":
       break;
     case "step_await":
@@ -953,22 +967,24 @@ var RuntypeFlowBuilder = class {
           onFlowComplete: (event) => callbacks?.onFlowComplete?.(event),
           onError: (error) => callbacks?.onError?.(error)
         };
-        const { streamEvents: streamEvents2 } = await Promise.resolve().then(() => (init_stream_utils(), stream_utils_exports));
+        const { streamEvents: streamEvents2, stepDeltaText: stepDeltaText2, stepDisplayName: stepDisplayName2, flowErrorMessage: flowErrorMessage2 } = await Promise.resolve().then(() => (init_stream_utils(), stream_utils_exports));
         try {
           for await (const event of streamEvents2(response)) {
             const awaitEvent = event;
             if (awaitEvent.type === "flow_await") {
+              const prev = pausedState;
               pausedState = {
-                toolName: awaitEvent.toolName || "",
-                parameters: awaitEvent.parameters,
-                executionId: awaitEvent.executionId || ""
+                toolName: awaitEvent.toolName || prev?.toolName || "",
+                parameters: awaitEvent.parameters ?? prev?.parameters,
+                executionId: awaitEvent.executionId || prev?.executionId || ""
               };
             }
             if (awaitEvent.type === "step_await") {
+              const prev = pausedState;
               pausedState = {
-                toolName: awaitEvent.toolName || "",
-                parameters: awaitEvent.parameters,
-                executionId: awaitEvent.executionId || ""
+                toolName: awaitEvent.toolName || prev?.toolName || "",
+                parameters: awaitEvent.parameters ?? prev?.parameters,
+                executionId: awaitEvent.executionId || prev?.executionId || ""
               };
             }
             switch (event.type) {
@@ -979,10 +995,10 @@ var RuntypeFlowBuilder = class {
                 wrappedCallbacks.onStepStart?.(event);
                 break;
               case "step_delta":
-                wrappedCallbacks.onStepDelta?.(event.text, event);
+                wrappedCallbacks.onStepDelta?.(stepDeltaText2(event), event);
                 break;
               case "step_complete": {
-                accumulatedSummary.results?.set(event.name, event.result);
+                accumulatedSummary.results?.set(stepDisplayName2(event), event.result);
                 wrappedCallbacks.onStepComplete?.(event.result, event);
                 break;
               }
@@ -990,7 +1006,7 @@ var RuntypeFlowBuilder = class {
                 wrappedCallbacks.onFlowComplete?.(event);
                 break;
               case "flow_error":
-                wrappedCallbacks.onError?.(new Error(event.error));
+                wrappedCallbacks.onError?.(new Error(flowErrorMessage2(event)));
                 break;
             }
           }
@@ -7023,6 +7039,363 @@ _AgentsEndpoint.STOP_PHRASES = [
   "STATUS: COMPLETE"
 ];
 var AgentsEndpoint = _AgentsEndpoint;
+var SecretsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all secrets (metadata only) for the authenticated user/org.
+   */
+  async list() {
+    return this.client.get("/secrets");
+  }
+  /**
+   * Get metadata for a single secret by ID.
+   */
+  async get(id) {
+    const response = await this.client.get(`/secrets/${id}`);
+    return response.data;
+  }
+  /**
+   * Create a secret. Omitting `value` provisions a key with no value yet
+   * (get-or-create semantics).
+   */
+  async create(data) {
+    const response = await this.client.post("/secrets", data);
+    return response.data;
+  }
+  /**
+   * Update or rotate a secret. Pass `expectedVersion` for optimistic concurrency.
+   */
+  async update(id, data) {
+    const response = await this.client.put(`/secrets/${id}`, data);
+    return response.data;
+  }
+  /**
+   * Delete a secret. Returns the number of tool configs that still reference it.
+   */
+  async delete(id) {
+    return this.client.delete(`/secrets/${id}`);
+  }
+  /**
+   * Check which of the given keys exist, are missing, or are revoked.
+   */
+  async check(keys) {
+    return this.client.post("/secrets/check", { keys });
+  }
+  /**
+   * Generate a dashboard URL for configuring missing secrets.
+   */
+  async setupUrl(data) {
+    return this.client.post("/secrets/setup-url", data);
+  }
+};
+var SchedulesEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List schedules with cursor pagination. Filter by `search` (name) or `status`.
+   */
+  async list(params) {
+    return this.client.get("/schedules", params);
+  }
+  /**
+   * Get a single schedule by ID.
+   */
+  async get(id) {
+    return this.client.get(`/schedules/${id}`);
+  }
+  /**
+   * Create a schedule. Provide exactly one of `target.flowId` or `target.agentId`.
+   */
+  async create(data) {
+    return this.client.post("/schedules", data);
+  }
+  /**
+   * Update a schedule (partial update supported).
+   */
+  async update(id, data) {
+    return this.client.put(`/schedules/${id}`, data);
+  }
+  /**
+   * Delete a schedule.
+   */
+  async delete(id) {
+    return this.client.delete(`/schedules/${id}`);
+  }
+  /**
+   * Trigger an immediate execution, bypassing the schedule's normal timing.
+   */
+  async runNow(id) {
+    return this.client.post(`/schedules/${id}/run-now`);
+  }
+  /**
+   * Pause a schedule (prevents future executions until resumed).
+   */
+  async pause(id) {
+    return this.client.post(`/schedules/${id}/pause`);
+  }
+  /**
+   * Resume a paused schedule.
+   */
+  async resume(id) {
+    return this.client.post(`/schedules/${id}/resume`);
+  }
+  /**
+   * List the run history for a specific schedule.
+   */
+  async listRuns(id) {
+    return this.client.get(`/schedules/${id}/runs`);
+  }
+  /**
+   * Get statistics (success rate, average duration/cost, 7-day history) for a schedule.
+   */
+  async getStats(id) {
+    return this.client.get(`/schedules/${id}/stats`);
+  }
+  /**
+   * List all runs across every schedule the user owns.
+   */
+  async listAllRuns(params) {
+    return this.client.get("/schedules/runs/all", params);
+  }
+};
+var SurfacesEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List surfaces with cursor pagination. Filter by `type`, `status`, or `environment`.
+   */
+  async list(params) {
+    return this.client.get("/surfaces", params);
+  }
+};
+var ConversationsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List conversations. Filter by source, surface, client token, or owner.
+   *
+   * Note: this endpoint returns a bespoke `{ conversations, pagination }`
+   * envelope rather than the standard `{ data, pagination }` shape.
+   */
+  async list(params) {
+    const query = {};
+    if (params?.source !== void 0) query.source = params.source;
+    if (params?.surfaceId !== void 0) query.surface_id = params.surfaceId;
+    if (params?.clientTokenId !== void 0) query.client_token_id = params.clientTokenId;
+    if (params?.ownerId !== void 0) query.ownerId = params.ownerId;
+    if (params?.limit !== void 0) query.limit = params.limit;
+    if (params?.cursor !== void 0) query.cursor = params.cursor;
+    return this.client.get("/conversations", query);
+  }
+  /**
+   * Get a single conversation (including its messages) by ID.
+   */
+  async get(id) {
+    return this.client.get(`/conversations/${id}`);
+  }
+  /**
+   * Create a conversation.
+   */
+  async create(data) {
+    return this.client.post("/conversations", data ?? {});
+  }
+  /**
+   * Update a conversation (title, model, system prompt, owner, metadata, messages).
+   */
+  async update(id, data) {
+    return this.client.put(`/conversations/${id}`, data);
+  }
+  /**
+   * Delete a conversation.
+   */
+  async delete(id) {
+    return this.client.delete(`/conversations/${id}`);
+  }
+};
+var LogsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Query logs with filtering and cursor pagination. Returns the
+   * `{ success, data: { entries, pagination } }` envelope.
+   */
+  async list(params) {
+    return this.client.get("/logs", params);
+  }
+  /**
+   * Convenience wrapper around {@link list} that returns just the log entries.
+   */
+  async listEntries(params) {
+    const response = await this.list(params);
+    return response.data.entries;
+  }
+  /**
+   * Get aggregate log statistics (counts by level/category, time-series histogram).
+   */
+  async getStats(params) {
+    return this.client.get("/logs/stats", params);
+  }
+  /**
+   * Get the trace tree for a single execution.
+   */
+  async traceExecution(executionId) {
+    return this.client.get(`/logs/trace/execution/${executionId}`);
+  }
+  /**
+   * Get the trace tree for a conversation (all executions within it).
+   */
+  async traceConversation(conversationId) {
+    return this.client.get(`/logs/trace/conversation/${conversationId}`);
+  }
+};
+var AgentVersionsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List versions for an agent, optionally filtered by version `type`.
+   */
+  async list(agentId, params) {
+    return this.client.get(`/agent-versions/${agentId}`, params);
+  }
+  /**
+   * Get the published version for an agent.
+   */
+  async getPublished(agentId) {
+    return this.client.get(`/agent-versions/${agentId}/published`);
+  }
+  /**
+   * Get a specific version of an agent.
+   */
+  async get(agentId, versionId) {
+    return this.client.get(`/agent-versions/${agentId}/${versionId}`);
+  }
+  /**
+   * Publish a version (promote it to the agent's published version).
+   */
+  async publish(agentId, versionId) {
+    return this.client.post(`/agent-versions/${agentId}/publish`, {
+      versionId
+    });
+  }
+};
+var FlowVersionsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List versions for a flow, optionally filtered by version `type`.
+   */
+  async list(flowId, params) {
+    return this.client.get(`/flow-versions/${flowId}`, params);
+  }
+  /**
+   * Get the published version for a flow.
+   */
+  async getPublished(flowId) {
+    return this.client.get(`/flow-versions/${flowId}/published`);
+  }
+  /**
+   * Get a specific version of a flow.
+   */
+  async get(flowId, versionId) {
+    return this.client.get(`/flow-versions/${flowId}/${versionId}`);
+  }
+  /**
+   * Publish a version (promote it to the flow's published version).
+   */
+  async publish(flowId, versionId) {
+    return this.client.post(`/flow-versions/${flowId}/publish`, {
+      versionId
+    });
+  }
+};
+var IntegrationsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all integrations with the caller's per-integration configuration status.
+   */
+  async list(params) {
+    return this.client.get("/integrations", params);
+  }
+  /**
+   * Get a single integration by ID.
+   */
+  async get(integrationId) {
+    return this.client.get(`/integrations/${integrationId}`);
+  }
+  /**
+   * List integrations within a category (e.g. `slack`, `mcp`).
+   */
+  async listByCategory(category) {
+    return this.client.get(
+      `/integrations/category/${category}`
+    );
+  }
+  /**
+   * Per-environment credential status across the caller's integrations.
+   */
+  async getCredentialsStatus() {
+    return this.client.get("/integrations/credentials-status");
+  }
+  /**
+   * List all tools exposed across the caller's configured integrations.
+   */
+  async listTools() {
+    return this.client.get("/integrations/tools");
+  }
+  /**
+   * List the tools exposed by a single integration.
+   */
+  async getIntegrationTools(integrationId) {
+    return this.client.get(
+      `/integrations/${integrationId}/tools`
+    );
+  }
+  /**
+   * Get the definition of a single tool within an integration.
+   */
+  async getTool(integrationId, toolName) {
+    return this.client.get(`/integrations/${integrationId}/tools/${toolName}`);
+  }
+  /**
+   * Install a Slack integration from a completed OAuth handshake.
+   */
+  async installSlack(data) {
+    return this.client.post("/integrations/slack/install", data);
+  }
+};
+var BillingEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get the caller's subscription status, plan limits, and current usage.
+   */
+  async getStatus() {
+    return this.client.get("/billing/status");
+  }
+  /**
+   * Get the caller's credit grants and available/used totals.
+   */
+  async getCredits() {
+    return this.client.get("/billing/credits");
+  }
+  /**
+   * Get spend analytics. The window is controlled by `days` (1–365, defaults to 30).
+   */
+  async getSpendAnalytics(params) {
+    return this.client.get("/billing/spend-analytics", params);
+  }
+};
 
 // src/flow-builder.ts
 init_stream_utils();
@@ -7752,7 +8125,7 @@ var RuntypeClient2 = class {
     const baseUrl = config.baseUrl || "https://api.runtype.com";
     this.apiVersion = config.apiVersion || "v1";
     this.baseUrl = this.apiVersion ? `${baseUrl}/${this.apiVersion}` : baseUrl;
-    this.timeout = config.timeout || 3e4;
+    this.timeout = config.timeout === void 0 ? 3e4 : config.timeout;
     this.headers = {
       "Content-Type": "application/json",
       ...config.headers || {}
@@ -7775,6 +8148,15 @@ var RuntypeClient2 = class {
     this.eval = new EvalEndpoint(this);
     this.clientTokens = new ClientTokensEndpoint(this);
     this.agents = new AgentsEndpoint(this);
+    this.secrets = new SecretsEndpoint(this);
+    this.schedules = new SchedulesEndpoint(this);
+    this.surfaces = new SurfacesEndpoint(this);
+    this.conversations = new ConversationsEndpoint(this);
+    this.logs = new LogsEndpoint(this);
+    this.agentVersions = new AgentVersionsEndpoint(this);
+    this.flowVersions = new FlowVersionsEndpoint(this);
+    this.integrations = new IntegrationsEndpoint(this);
+    this.billing = new BillingEndpoint(this);
   }
   /**
    * Set the API key for authentication
@@ -7816,9 +8198,7 @@ var RuntypeClient2 = class {
     const options = (isOptionsObject(arg3) ? arg3 : arg4) ?? {};
     const scope = options.scope ?? "session";
     const isStreaming = !!callbacks;
-    const derivedClientTools = scope === "turn" ? Object.entries(localTools).filter(
-      (entry) => hasToolEntryShape(entry[1])
-    ).map(([name, entry]) => ({
+    const derivedClientTools = scope === "turn" ? Object.entries(localTools).filter((entry) => hasToolEntryShape(entry[1])).map(([name, entry]) => ({
       name,
       description: entry.description,
       parametersSchema: entry.parametersSchema,
@@ -7847,7 +8227,7 @@ var RuntypeClient2 = class {
           onFlowComplete: (event) => callbacks?.onFlowComplete?.(event),
           onError: (error) => callbacks?.onError?.(error)
         };
-        const { streamEvents: streamEvents2 } = await Promise.resolve().then(() => (init_stream_utils(), stream_utils_exports));
+        const { streamEvents: streamEvents2, stepDeltaText: stepDeltaText2, stepDisplayName: stepDisplayName2, flowErrorMessage: flowErrorMessage2 } = await Promise.resolve().then(() => (init_stream_utils(), stream_utils_exports));
         const summary = {
           results: /* @__PURE__ */ new Map(),
           success: true
@@ -7856,19 +8236,23 @@ var RuntypeClient2 = class {
           for await (const event of streamEvents2(response)) {
             if (event.type === "flow_await") {
               const pausedEvent = event;
-              pausedState = {
-                ...pausedState ?? {},
-                toolName: pausedEvent.toolName,
-                executionId: pausedEvent.executionId
+              const prev = pausedState;
+              const next = {
+                toolName: pausedEvent.toolName ?? prev?.toolName ?? "",
+                executionId: pausedEvent.executionId ?? prev?.executionId ?? "",
+                parameters: prev?.parameters
               };
+              pausedState = next;
             }
             if (event.type === "step_await") {
               const pausedEvent = event;
-              pausedState = {
-                toolName: pausedEvent.toolName,
+              const prev = pausedState;
+              const next = {
+                toolName: typeof pausedEvent.toolName === "string" ? pausedEvent.toolName : prev?.toolName ?? "",
                 parameters: pausedEvent.parameters,
-                executionId: pausedEvent.executionId
+                executionId: typeof pausedEvent.executionId === "string" ? pausedEvent.executionId : prev?.executionId ?? ""
               };
+              pausedState = next;
             }
             switch (event.type) {
               case "flow_start":
@@ -7878,10 +8262,10 @@ var RuntypeClient2 = class {
                 wrappedCallbacks.onStepStart?.(event);
                 break;
               case "step_delta":
-                wrappedCallbacks.onStepDelta?.(event.text, event);
+                wrappedCallbacks.onStepDelta?.(stepDeltaText2(event), event);
                 break;
               case "step_complete": {
-                summary.results?.set(event.name, event.result);
+                summary.results?.set(stepDisplayName2(event), event.result);
                 wrappedCallbacks.onStepComplete?.(event.result, event);
                 break;
               }
@@ -7889,7 +8273,7 @@ var RuntypeClient2 = class {
                 wrappedCallbacks.onFlowComplete?.(event);
                 break;
               case "flow_error":
-                wrappedCallbacks.onError?.(new Error(event.error));
+                wrappedCallbacks.onError?.(new Error(flowErrorMessage2(event)));
                 break;
             }
           }
@@ -8085,14 +8469,14 @@ var RuntypeClient2 = class {
    * Make HTTP request with timeout and error handling
    */
   async makeRequest(url, options) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    const controller = this.timeout === null ? null : new AbortController();
+    const timeoutId = controller && this.timeout !== null ? setTimeout(() => controller.abort(), this.timeout) : null;
     try {
       const response = await fetch(url, {
         ...options,
-        signal: controller.signal
+        ...controller ? { signal: controller.signal } : {}
       });
-      clearTimeout(timeoutId);
+      if (timeoutId) clearTimeout(timeoutId);
       if (!response.ok) {
         throw await this.createApiError(response);
       }
@@ -8105,8 +8489,8 @@ var RuntypeClient2 = class {
       }
       return response.text();
     } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof Error && error.name === "AbortError") {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (timeoutId && error instanceof Error && error.name === "AbortError") {
         throw new Error(`Request timeout after ${this.timeout}ms`);
       }
       throw error;
@@ -8116,21 +8500,21 @@ var RuntypeClient2 = class {
    * Make HTTP request that returns raw Response (for streaming)
    */
   async makeRawRequest(url, options) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    const controller = this.timeout === null ? null : new AbortController();
+    const timeoutId = controller && this.timeout !== null ? setTimeout(() => controller.abort(), this.timeout) : null;
     try {
       const response = await fetch(url, {
         ...options,
-        signal: controller.signal
+        ...controller ? { signal: controller.signal } : {}
       });
-      clearTimeout(timeoutId);
+      if (timeoutId) clearTimeout(timeoutId);
       if (!response.ok) {
         throw await this.createApiError(response);
       }
       return response;
     } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof Error && error.name === "AbortError") {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (timeoutId && error instanceof Error && error.name === "AbortError") {
         throw new Error(`Request timeout after ${this.timeout}ms`);
       }
       throw error;
@@ -8708,17 +9092,20 @@ var STEP_TYPE_TO_METHOD = {
   "generate-pdf": "generatePdf"
 };
 export {
+  AgentVersionsEndpoint,
   AgentsEndpoint,
   AnalyticsEndpoint,
   ApiKeysEndpoint,
   BatchBuilder,
   BatchesNamespace,
+  BillingEndpoint,
   ChatEndpoint,
   ClientBatchBuilder,
   ClientEvalBuilder,
   ClientFlowBuilder,
   ClientTokensEndpoint,
   ContextTemplatesEndpoint,
+  ConversationsEndpoint,
   DispatchEndpoint,
   EvalBuilder,
   EvalEndpoint,
@@ -8727,8 +9114,11 @@ export {
   FlowBuilder,
   FlowResult,
   FlowStepsEndpoint,
+  FlowVersionsEndpoint,
   FlowsEndpoint,
   FlowsNamespace,
+  IntegrationsEndpoint,
+  LogsEndpoint,
   ModelConfigsEndpoint,
   PromptRunner,
   PromptsEndpoint,
@@ -8740,6 +9130,9 @@ export {
   RuntypeFlowBuilder,
   STEP_FIELD_REGISTRY,
   STEP_TYPE_TO_METHOD,
+  SchedulesEndpoint,
+  SecretsEndpoint,
+  SurfacesEndpoint,
   ToolsEndpoint,
   UsersEndpoint,
   applyGeneratedRuntimeToolProposalToDispatchRequest,