@runtypelabs/sdk 2.1.1 → 3.0.0

package/dist/index.cjs

@@ -23,9 +23,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // 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) {
@@ -146,7 +149,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);
         }
       }
@@ -156,7 +159,7 @@ async function processStream(response, callbacks = {}) {
       try {
         const event = JSON.parse(finalEvent);
         handleEvent(event, callbacks, results, flowSummary);
-      } catch (parseError) {
+      } catch {
       }
     }
   } catch (error) {
@@ -178,6 +181,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":
@@ -190,24 +202,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":
@@ -275,17 +289,20 @@ var init_stream_utils = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AgentVersionsEndpoint: () => AgentVersionsEndpoint,
   AgentsEndpoint: () => AgentsEndpoint,
   AnalyticsEndpoint: () => AnalyticsEndpoint,
   ApiKeysEndpoint: () => ApiKeysEndpoint,
   BatchBuilder: () => BatchBuilder,
   BatchesNamespace: () => BatchesNamespace,
+  BillingEndpoint: () => BillingEndpoint,
   ChatEndpoint: () => ChatEndpoint,
   ClientBatchBuilder: () => ClientBatchBuilder,
   ClientEvalBuilder: () => ClientEvalBuilder,
   ClientFlowBuilder: () => ClientFlowBuilder,
   ClientTokensEndpoint: () => ClientTokensEndpoint,
   ContextTemplatesEndpoint: () => ContextTemplatesEndpoint,
+  ConversationsEndpoint: () => ConversationsEndpoint,
   DispatchEndpoint: () => DispatchEndpoint,
   EvalBuilder: () => EvalBuilder,
   EvalEndpoint: () => EvalEndpoint,
@@ -294,8 +311,11 @@ __export(index_exports, {
   FlowBuilder: () => FlowBuilder,
   FlowResult: () => FlowResult,
   FlowStepsEndpoint: () => FlowStepsEndpoint,
+  FlowVersionsEndpoint: () => FlowVersionsEndpoint,
   FlowsEndpoint: () => FlowsEndpoint,
   FlowsNamespace: () => FlowsNamespace,
+  IntegrationsEndpoint: () => IntegrationsEndpoint,
+  LogsEndpoint: () => LogsEndpoint,
   ModelConfigsEndpoint: () => ModelConfigsEndpoint,
   PromptRunner: () => PromptRunner,
   PromptsEndpoint: () => PromptsEndpoint,
@@ -307,6 +327,9 @@ __export(index_exports, {
   RuntypeFlowBuilder: () => RuntypeFlowBuilder,
   STEP_FIELD_REGISTRY: () => STEP_FIELD_REGISTRY,
   STEP_TYPE_TO_METHOD: () => STEP_TYPE_TO_METHOD,
+  SchedulesEndpoint: () => SchedulesEndpoint,
+  SecretsEndpoint: () => SecretsEndpoint,
+  SurfacesEndpoint: () => SurfacesEndpoint,
   ToolsEndpoint: () => ToolsEndpoint,
   UsersEndpoint: () => UsersEndpoint,
   applyGeneratedRuntimeToolProposalToDispatchRequest: () => applyGeneratedRuntimeToolProposalToDispatchRequest,
@@ -1025,22 +1048,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) {
@@ -1051,10 +1076,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;
               }
@@ -1062,7 +1087,7 @@ var RuntypeFlowBuilder = class {
                 wrappedCallbacks.onFlowComplete?.(event);
                 break;
               case "flow_error":
-                wrappedCallbacks.onError?.(new Error(event.error));
+                wrappedCallbacks.onError?.(new Error(flowErrorMessage2(event)));
                 break;
             }
           }
@@ -7095,6 +7120,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();
@@ -7824,7 +8206,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 || {}
@@ -7847,6 +8229,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
@@ -7888,9 +8279,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,
@@ -7919,7 +8308,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
@@ -7928,19 +8317,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":
@@ -7950,10 +8343,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;
               }
@@ -7961,7 +8354,7 @@ var RuntypeClient2 = class {
                 wrappedCallbacks.onFlowComplete?.(event);
                 break;
               case "flow_error":
-                wrappedCallbacks.onError?.(new Error(event.error));
+                wrappedCallbacks.onError?.(new Error(flowErrorMessage2(event)));
                 break;
             }
           }
@@ -8157,14 +8550,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);
       }
@@ -8177,8 +8570,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;
@@ -8188,21 +8581,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;
@@ -8781,17 +9174,20 @@ var STEP_TYPE_TO_METHOD = {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AgentVersionsEndpoint,
   AgentsEndpoint,
   AnalyticsEndpoint,
   ApiKeysEndpoint,
   BatchBuilder,
   BatchesNamespace,
+  BillingEndpoint,
   ChatEndpoint,
   ClientBatchBuilder,
   ClientEvalBuilder,
   ClientFlowBuilder,
   ClientTokensEndpoint,
   ContextTemplatesEndpoint,
+  ConversationsEndpoint,
   DispatchEndpoint,
   EvalBuilder,
   EvalEndpoint,
@@ -8800,8 +9196,11 @@ var STEP_TYPE_TO_METHOD = {
   FlowBuilder,
   FlowResult,
   FlowStepsEndpoint,
+  FlowVersionsEndpoint,
   FlowsEndpoint,
   FlowsNamespace,
+  IntegrationsEndpoint,
+  LogsEndpoint,
   ModelConfigsEndpoint,
   PromptRunner,
   PromptsEndpoint,
@@ -8813,6 +9212,9 @@ var STEP_TYPE_TO_METHOD = {
   RuntypeFlowBuilder,
   STEP_FIELD_REGISTRY,
   STEP_TYPE_TO_METHOD,
+  SchedulesEndpoint,
+  SecretsEndpoint,
+  SurfacesEndpoint,
   ToolsEndpoint,
   UsersEndpoint,
   applyGeneratedRuntimeToolProposalToDispatchRequest,