@runtypelabs/sdk 9.1.0 → 9.2.0

package/dist/index.mjs

@@ -216,7 +216,8 @@ function createAgentEventTranslator() {
             agentName: data.agentName,
             maxTurns: data.maxTurns,
             startedAt: data.startedAt,
-            config: data.config
+            config: data.config,
+            resumed: data.resumed
           })
         ];
       case "turn_start":
@@ -354,6 +355,10 @@ function createAgentEventTranslator() {
             toolName: data.toolName,
             success: data.success,
             result: data.result,
+            // A failure's reason travels on the frame's `error` field — the
+            // only carrier for complete-only failures like the MCP discovery
+            // connection pseudo-tool, which no longer emits an `error` frame.
+            error: str(data.error),
             executionTime: data.executionTime
           })
         ];
@@ -1215,6 +1220,24 @@ var FlowBuilder = class {
     );
     return this;
   }
+  /**
+   * Add a bounded do-while loop step.
+   */
+  loop(config) {
+    this.addStep(
+      "loop",
+      config.name,
+      {
+        steps: config.steps,
+        until: config.until,
+        maxIterations: config.maxIterations,
+        iterationVariable: config.iterationVariable
+      },
+      config.enabled,
+      config.when
+    );
+    return this;
+  }
   /**
    * Add a search step
    */
@@ -3037,6 +3060,24 @@ var RuntypeFlowBuilder = class {
     );
     return this;
   }
+  /**
+   * Add a bounded do-while loop step.
+   */
+  loop(config) {
+    this.addStep(
+      "loop",
+      config.name,
+      {
+        steps: config.steps,
+        until: config.until,
+        maxIterations: config.maxIterations,
+        iterationVariable: config.iterationVariable
+      },
+      config.enabled,
+      config.when
+    );
+    return this;
+  }
   /**
    * Add a search step
    */
@@ -4963,6 +5004,16 @@ var AgentsNamespace = class {
   }
 };
 
+// src/executions-namespace.ts
+var ExecutionsNamespace = class {
+  constructor(getClient) {
+    this.getClient = getClient;
+  }
+  getStatus(executionId) {
+    return this.getClient().getExecutionStatus(executionId);
+  }
+};
+
 // src/tools-ensure.ts
 function normalizeToolDefinition(definition) {
   const parametersSchema = isPlainObject(definition.parametersSchema) ? normalizeValue(definition.parametersSchema) : {};
@@ -5707,6 +5758,11 @@ function transformQueryParams(params) {
   return result;
 }
 
+// src/types.ts
+function isCatalogClientToolRef(entry) {
+  return entry.catalog === "runtype-mcp";
+}
+
 // src/dispatch-request.ts
 function normalizeDispatchMessageContent(content) {
   if (Array.isArray(content) && content.some(
@@ -5731,6 +5787,9 @@ function normalizeDispatchRequest(request6) {
     content: normalizeDispatchMessageContent(message.content)
   }));
   const clientTools = request6.clientTools?.map((tool) => {
+    if (isCatalogClientToolRef(tool)) {
+      return tool;
+    }
     if (tool.parametersSchema.type !== "object") {
       throw new Error(`Client tool "${tool.name}" parametersSchema.type must be "object"`);
     }
@@ -5786,11 +5845,11 @@ var RuntypeClient = class {
   /**
    * Generic POST request
    */
-  async post(path, data) {
+  async post(path, data, extraHeaders) {
     const url = this.buildUrl(path);
     const response = await this.makeRequest(url, {
       method: "POST",
-      headers: this.headers,
+      headers: { ...this.headers, ...extraHeaders },
       body: data ? JSON.stringify(data) : void 0
     });
     return this.transformResponse(response);
@@ -5883,6 +5942,21 @@ var RuntypeClient = class {
       }
     });
   }
+  /** Start a normalized dispatch and return a durable handle immediately. */
+  async dispatchAsync(config) {
+    const normalized = normalizeDispatchRequest(config);
+    return this.post(
+      "/dispatch",
+      {
+        ...normalized,
+        options: { ...normalized.options, streamResponse: false }
+      },
+      { Prefer: "respond-async" }
+    );
+  }
+  async getExecutionStatus(executionId) {
+    return this.get(`/executions/${encodeURIComponent(executionId)}/status`);
+  }
   /**
    * Build full URL with query parameters
    */
@@ -6157,6 +6231,10 @@ var Runtype = class {
   static get agents() {
     return new AgentsNamespace(() => this.getClient());
   }
+  /** Poll durable handles returned by asynchronous execute operations. */
+  static get executions() {
+    return new ExecutionsNamespace(() => this.getClient());
+  }
   /**
    * Tools namespace - Tool config-as-code (define / ensure / pull)
    *
@@ -6249,7 +6327,7 @@ var Runtype = class {
 
 // src/version.ts
 var FALLBACK_VERSION = "0.0.0";
-var SDK_VERSION = "9.1.0".length > 0 ? "9.1.0" : FALLBACK_VERSION;
+var SDK_VERSION = "9.2.0".length > 0 ? "9.2.0" : FALLBACK_VERSION;
 var RUNTYPE_CLIENT_KIND = "sdk";
 var SDK_USER_AGENT = `runtype-sdk/${SDK_VERSION} (typescript)`;
 
@@ -8632,9 +8710,72 @@ var CollectionsEndpoint = class {
     return this.client.get("/collections/types.d.ts");
   }
 };
+var ApiKeyRequestsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * File a request. Nothing is minted; the response carries the request, the
+   * browser handoff a human must complete, and a suggested poll interval.
+   */
+  async create(data) {
+    return this.client.post("/api-keys/requests", data);
+  }
+  /**
+   * Read one request — poll this for the approval decision.
+   *
+   * The route answers with the `{ request, handoff? }` envelope (the handoff is
+   * present only while a human still has to act), so unwrap it the way `list()`
+   * unwraps `{ requests }`. Returning the envelope raw types as `ApiKeyRequest`
+   * but has no `status`, which silently reads as `undefined` in every caller's
+   * state machine rather than failing anywhere near here.
+   */
+  async get(requestId) {
+    const response = await this.client.get(
+      `/api-keys/requests/${requestId}`
+    );
+    return response.request;
+  }
+  /**
+   * Read one request together with its browser handoff. Same route as `get()`;
+   * use this when re-raising the approval prompt for a request this process did
+   * not file (the handoff is absent once the request leaves `pending`).
+   */
+  async getWithHandoff(requestId) {
+    return this.client.get(`/api-keys/requests/${requestId}`);
+  }
+  /**
+   * List requests for the account. Clerk-session surface (the human review
+   * queue); an API key sees only its own requests.
+   */
+  async list(params) {
+    const response = await this.client.get(
+      "/api-keys/requests",
+      params
+    );
+    return response.requests;
+  }
+  /**
+   * Redeem an approved request. The key is minted here and returned exactly
+   * once: `delivery: 'inline'` (the API default) puts the plaintext in
+   * `apiKey`; `delivery: 'secret'` stores it as a Runtype secret and returns
+   * only a `{{secret:KEY}}` reference in `secretRef`. Claiming twice is a 409.
+   */
+  async claim(requestId, data) {
+    return this.client.post(
+      `/api-keys/requests/${requestId}/claim`,
+      data
+    );
+  }
+  /** Withdraw a pending request you filed. Cannot be undone. */
+  async cancel(requestId) {
+    return this.client.post(`/api-keys/requests/${requestId}/cancel`);
+  }
+};
 var ApiKeysEndpoint = class {
   constructor(client) {
     this.client = client;
+    this.requests = new ApiKeyRequestsEndpoint(client);
   }
   /**
    * List all API keys for the authenticated user
@@ -8889,6 +9030,18 @@ var DispatchEndpoint = class {
       }
     });
   }
+  /** Start a dispatch and return its durable execution handle immediately. */
+  async executeAsync(data) {
+    const normalized = normalizeDispatchRequest(data);
+    return this.client.post(
+      "/dispatch",
+      {
+        ...normalized,
+        options: { ...normalized.options, streamResponse: false }
+      },
+      { Prefer: "respond-async" }
+    );
+  }
   /**
    * Dispatch with streaming response
    */
@@ -8956,6 +9109,16 @@ var DispatchEndpoint = class {
     return applyGeneratedRuntimeToolProposalToDispatchRequest(request6, proposal, options);
   }
 };
+var ExecutionsEndpoint = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getStatus(executionId) {
+    return this.client.get(
+      `/executions/${encodeURIComponent(executionId)}/status`
+    );
+  }
+};
 var ChatEndpoint = class {
   constructor(client) {
     this.client = client;
@@ -9645,6 +9808,14 @@ var _AgentsEndpoint = class _AgentsEndpoint {
       streamResponse: false
     });
   }
+  /** Start an agent execution and return its durable handle immediately. */
+  async executeAsync(id, data) {
+    return this.client.post(
+      `/agents/${id}/execute`,
+      { ...data, streamResponse: false },
+      { Prefer: "respond-async" }
+    );
+  }
   /**
    * Execute an agent with streaming response
    *
@@ -9817,7 +9988,7 @@ var _AgentsEndpoint = class _AgentsEndpoint {
           ...callbacks,
           onAgentStart: (event) => {
             lastSeenExecutionId = event.executionId;
-            callbacks?.onAgentStart?.(event);
+            if (!event.resumed) callbacks?.onAgentStart?.(event);
           },
           onTurnDelta: (event) => {
             if (event.contentType === "text") {
@@ -12811,9 +12982,7 @@ function assertTurnScopedLocalTools(localTools) {
       );
     }
     if (entry.parametersSchema.type !== "object") {
-      throw new Error(
-        `Turn-scoped local tool "${name}" parametersSchema.type must be "object"`
-      );
+      throw new Error(`Turn-scoped local tool "${name}" parametersSchema.type must be "object"`);
     }
   }
 }
@@ -12849,6 +13018,7 @@ var RuntypeClient2 = class {
     this.modelConfigs = new ModelConfigsEndpoint(this);
     this.providerKeys = new ProviderKeysEndpoint(this);
     this.dispatch = new DispatchEndpoint(this);
+    this.executions = new ExecutionsEndpoint(this);
     this.chat = new ChatEndpoint(this);
     this.users = new UsersEndpoint(this);
     this.analytics = new AnalyticsEndpoint(this);
@@ -13116,11 +13286,11 @@ var RuntypeClient2 = class {
   /**
    * Generic POST request
    */
-  async post(path, data) {
+  async post(path, data, extraHeaders) {
     const url = this.buildUrl(path);
     const response = await this.makeRequest(url, {
       method: "POST",
-      headers: this.headers,
+      headers: { ...this.headers, ...extraHeaders },
       body: data ? JSON.stringify(transformRequest(data)) : void 0
     });
     return transformResponse(response);
@@ -13715,6 +13885,12 @@ var CONDITIONAL_FIELDS = [
   { key: "trueSteps", format: "value" },
   { key: "falseSteps", format: "value" }
 ];
+var LOOP_FIELDS = [
+  { key: "steps", format: "value" },
+  { key: "until", format: "template" },
+  { key: "maxIterations", format: "raw" },
+  { key: "iterationVariable", format: "json" }
+];
 var SEARCH_FIELDS = [
   { key: "provider", format: "json" },
   { key: "query", format: "template" },
@@ -14006,6 +14182,7 @@ var STEP_FIELD_REGISTRY = {
   "transform-data": TRANSFORM_DATA_FIELDS,
   "set-variable": SET_VARIABLE_FIELDS,
   conditional: CONDITIONAL_FIELDS,
+  loop: LOOP_FIELDS,
   search: SEARCH_FIELDS,
   "send-email": SEND_EMAIL_FIELDS,
   "send-stream": SEND_STREAM_FIELDS,
@@ -14040,6 +14217,7 @@ var STEP_TYPE_TO_METHOD = {
   "transform-data": "transformData",
   template: "template",
   conditional: "conditional",
+  loop: "loop",
   "set-variable": "setVariable",
   "upsert-record": "upsertRecord",
   "update-record": "updateRecord",
@@ -14067,6 +14245,7 @@ export {
   AgentsEndpoint,
   AgentsNamespace,
   AnalyticsEndpoint,
+  ApiKeyRequestsEndpoint,
   ApiKeysEndpoint,
   BatchBuilder,
   BatchesNamespace,
@@ -14087,6 +14266,8 @@ export {
   EvalRunner,
   EvalSuitesNamespace,
   EvalsNamespace,
+  ExecutionsEndpoint,
+  ExecutionsNamespace,
   FlowBuilder,
   FlowDriftError,
   FlowEnsureConflictError,
@@ -14178,6 +14359,7 @@ export {
   getDefaultPlanPath,
   getLikelySupportingCandidatePaths,
   interpolateWorkflowTemplate,
+  isCatalogClientToolRef,
   isDiscoveryToolName,
   isMarathonArtifactPath,
   isPreservationSensitiveTask,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/sdk",
-  "version": "9.1.0",
+  "version": "9.2.0",
   "type": "module",
   "description": "TypeScript SDK for the Runtype API with fluent methods. Use it to quickly realize AI products, agents, and workflows.",
   "main": "dist/index.cjs",