@runtypelabs/sdk 9.1.1 → 9.2.1

package/dist/index.cjs

@@ -26,6 +26,7 @@ __export(index_exports, {
   AgentsEndpoint: () => AgentsEndpoint,
   AgentsNamespace: () => AgentsNamespace,
   AnalyticsEndpoint: () => AnalyticsEndpoint,
+  ApiKeyRequestsEndpoint: () => ApiKeyRequestsEndpoint,
   ApiKeysEndpoint: () => ApiKeysEndpoint,
   BatchBuilder: () => BatchBuilder,
   BatchesNamespace: () => BatchesNamespace,
@@ -46,6 +47,8 @@ __export(index_exports, {
   EvalRunner: () => EvalRunner,
   EvalSuitesNamespace: () => EvalSuitesNamespace,
   EvalsNamespace: () => EvalsNamespace,
+  ExecutionsEndpoint: () => ExecutionsEndpoint,
+  ExecutionsNamespace: () => ExecutionsNamespace,
   FlowBuilder: () => FlowBuilder,
   FlowDriftError: () => FlowDriftError,
   FlowEnsureConflictError: () => FlowEnsureConflictError,
@@ -137,6 +140,7 @@ __export(index_exports, {
   getDefaultPlanPath: () => getDefaultPlanPath,
   getLikelySupportingCandidatePaths: () => getLikelySupportingCandidatePaths,
   interpolateWorkflowTemplate: () => interpolateWorkflowTemplate,
+  isCatalogClientToolRef: () => isCatalogClientToolRef,
   isDiscoveryToolName: () => isDiscoveryToolName,
   isMarathonArtifactPath: () => isMarathonArtifactPath,
   isPreservationSensitiveTask: () => isPreservationSensitiveTask,
@@ -1408,6 +1412,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
    */
@@ -3230,6 +3252,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
    */
@@ -5156,6 +5196,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) : {};
@@ -5900,6 +5950,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(
@@ -5924,6 +5979,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"`);
     }
@@ -5979,11 +6037,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);
@@ -6076,6 +6134,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
    */
@@ -6350,6 +6423,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)
    *
@@ -6442,7 +6519,7 @@ var Runtype = class {
 
 // src/version.ts
 var FALLBACK_VERSION = "0.0.0";
-var SDK_VERSION = "9.1.1".length > 0 ? "9.1.1" : FALLBACK_VERSION;
+var SDK_VERSION = "9.2.1".length > 0 ? "9.2.1" : FALLBACK_VERSION;
 var RUNTYPE_CLIENT_KIND = "sdk";
 var SDK_USER_AGENT = `runtype-sdk/${SDK_VERSION} (typescript)`;
 
@@ -8825,9 +8902,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
@@ -9082,6 +9222,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
    */
@@ -9149,6 +9301,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;
@@ -9838,6 +10000,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
    *
@@ -13004,9 +13174,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"`);
     }
   }
 }
@@ -13042,6 +13210,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);
@@ -13309,11 +13478,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);
@@ -13908,6 +14077,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" },
@@ -14199,6 +14374,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,
@@ -14233,6 +14409,7 @@ var STEP_TYPE_TO_METHOD = {
   "transform-data": "transformData",
   template: "template",
   conditional: "conditional",
+  loop: "loop",
   "set-variable": "setVariable",
   "upsert-record": "upsertRecord",
   "update-record": "updateRecord",
@@ -14261,6 +14438,7 @@ var STEP_TYPE_TO_METHOD = {
   AgentsEndpoint,
   AgentsNamespace,
   AnalyticsEndpoint,
+  ApiKeyRequestsEndpoint,
   ApiKeysEndpoint,
   BatchBuilder,
   BatchesNamespace,
@@ -14281,6 +14459,8 @@ var STEP_TYPE_TO_METHOD = {
   EvalRunner,
   EvalSuitesNamespace,
   EvalsNamespace,
+  ExecutionsEndpoint,
+  ExecutionsNamespace,
   FlowBuilder,
   FlowDriftError,
   FlowEnsureConflictError,
@@ -14372,6 +14552,7 @@ var STEP_TYPE_TO_METHOD = {
   getDefaultPlanPath,
   getLikelySupportingCandidatePaths,
   interpolateWorkflowTemplate,
+  isCatalogClientToolRef,
   isDiscoveryToolName,
   isMarathonArtifactPath,
   isPreservationSensitiveTask,