@runtypelabs/sdk 2.2.0 → 4.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":
@@ -315,6 +329,8 @@ __export(index_exports, {
   STEP_TYPE_TO_METHOD: () => STEP_TYPE_TO_METHOD,
   SchedulesEndpoint: () => SchedulesEndpoint,
   SecretsEndpoint: () => SecretsEndpoint,
+  SkillProposalsNamespace: () => SkillProposalsNamespace,
+  SkillsNamespace: () => SkillsNamespace,
   SurfacesEndpoint: () => SurfacesEndpoint,
   ToolsEndpoint: () => ToolsEndpoint,
   UsersEndpoint: () => UsersEndpoint,
@@ -1034,22 +1050,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) {
@@ -1060,10 +1078,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;
               }
@@ -1071,7 +1089,7 @@ var RuntypeFlowBuilder = class {
                 wrappedCallbacks.onFlowComplete?.(event);
                 break;
               case "flow_error":
-                wrappedCallbacks.onError?.(new Error(event.error));
+                wrappedCallbacks.onError?.(new Error(flowErrorMessage2(event)));
                 break;
             }
           }
@@ -1733,6 +1751,175 @@ var PromptsNamespace = class {
   }
 };
 
+// src/skills-namespace.ts
+var SkillProposalsNamespace = class {
+  constructor(getClient) {
+    this.getClient = getClient;
+  }
+  /**
+   * List pending skill proposals for the authenticated owner.
+   *
+   * @example
+   * ```typescript
+   * const pending = await Runtype.skills.proposals.list()
+   * ```
+   */
+  async list() {
+    const client = this.getClient();
+    const res = await client.get("/skill-proposals");
+    return res.data;
+  }
+  /**
+   * Approve a pending proposal — publishes the proposed skill version.
+   *
+   * @example
+   * ```typescript
+   * const proposal = await Runtype.skills.proposals.approve('skprop_123')
+   * ```
+   */
+  async approve(proposalId) {
+    const client = this.getClient();
+    const res = await client.post(
+      `/skill-proposals/${proposalId}/approve`
+    );
+    return res.proposal;
+  }
+  /**
+   * Reject a pending proposal with an optional reason.
+   *
+   * @example
+   * ```typescript
+   * await Runtype.skills.proposals.reject('skprop_123', 'Capabilities too broad')
+   * ```
+   */
+  async reject(proposalId, reason) {
+    const client = this.getClient();
+    const res = await client.post(
+      `/skill-proposals/${proposalId}/reject`,
+      reason !== void 0 ? { reason } : {}
+    );
+    return res.proposal;
+  }
+};
+var SkillsNamespace = class {
+  constructor(getClient) {
+    this.getClient = getClient;
+    this.proposals = new SkillProposalsNamespace(getClient);
+  }
+  /**
+   * Create a skill from a SKILL.md string (`markdown`) or a structured manifest
+   * (`frontmatter` + `body`). Pass `publish: true` to publish the first version
+   * immediately; otherwise it lands as a draft.
+   */
+  async create(input) {
+    const client = this.getClient();
+    return client.post("/skills", input);
+  }
+  /**
+   * List skills for the authenticated owner, optionally filtered by status.
+   *
+   * @example
+   * ```typescript
+   * const active = await Runtype.skills.list({ status: 'active' })
+   * ```
+   */
+  async list(params) {
+    const client = this.getClient();
+    const res = await client.get("/skills", params);
+    return res.data;
+  }
+  /**
+   * Get a skill and its full version history.
+   *
+   * @example
+   * ```typescript
+   * const { skill, versions } = await Runtype.skills.get('skill_123')
+   * ```
+   */
+  async get(skillId) {
+    const client = this.getClient();
+    return client.get(`/skills/${skillId}`);
+  }
+  /**
+   * Append a new version to an existing skill from an updated manifest. Pass
+   * `publish: true` to publish the new version immediately.
+   */
+  async update(skillId, input) {
+    const client = this.getClient();
+    const res = await client.put(`/skills/${skillId}`, input);
+    return res.version;
+  }
+  /**
+   * Delete a skill (and its versions + bindings, via cascade).
+   */
+  async delete(skillId) {
+    const client = this.getClient();
+    await client.delete(`/skills/${skillId}`);
+  }
+  /**
+   * List a skill's versions, newest first.
+   */
+  async listVersions(skillId) {
+    const client = this.getClient();
+    const res = await client.get(`/skills/${skillId}/versions`);
+    return res.data;
+  }
+  /**
+   * Publish a specific version of a skill.
+   *
+   * @example
+   * ```typescript
+   * await Runtype.skills.publishVersion('skill_123', 'skillver_456')
+   * ```
+   */
+  async publishVersion(skillId, versionId) {
+    const client = this.getClient();
+    await client.post(`/skills/${skillId}/versions/${versionId}/publish`);
+  }
+  /**
+   * Import a single SKILL.md document. The imported skill lands with
+   * `trustLevel: 'imported'` and a draft version.
+   *
+   * @example
+   * ```typescript
+   * const { skill } = await Runtype.skills.import(skillMarkdown)
+   * ```
+   */
+  async import(markdown) {
+    const client = this.getClient();
+    return client.post("/skills/import", { markdown });
+  }
+  /**
+   * Bind a skill to an agent. Both the agent and the skill must be owned by the
+   * caller.
+   */
+  async bind(input) {
+    const client = this.getClient();
+    const res = await client.post("/skills/bind", input);
+    return res.binding;
+  }
+  /**
+   * Remove a skill binding by its binding id.
+   */
+  async unbind(bindingId) {
+    const client = this.getClient();
+    await client.delete(`/skills/bindings/${bindingId}`);
+  }
+  /**
+   * List an agent's skill bindings.
+   *
+   * @example
+   * ```typescript
+   * const bindings = await Runtype.skills.listBindings('agent_123')
+   * ```
+   */
+  async listBindings(agentId) {
+    const client = this.getClient();
+    const res = await client.get("/skills/bindings", { agentId });
+    return res.data;
+  }
+};
+
 // src/transform.ts
 function transformResponse(data) {
   return data;
@@ -1780,6 +1967,7 @@ var RuntypeClient = class {
   /**
    * Generic GET request
    */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts typed list-param interfaces (no index signature); `unknown` would reject them
   async get(path, params) {
     const url = this.buildUrl(path, params);
     const response = await this.makeRequest(url, {
@@ -1800,6 +1988,29 @@ var RuntypeClient = class {
     });
     return this.transformResponse(response);
   }
+  /**
+   * Generic PUT request
+   */
+  async put(path, data) {
+    const url = this.buildUrl(path);
+    const response = await this.makeRequest(url, {
+      method: "PUT",
+      headers: this.headers,
+      body: data ? JSON.stringify(data) : void 0
+    });
+    return this.transformResponse(response);
+  }
+  /**
+   * Generic DELETE request
+   */
+  async delete(path) {
+    const url = this.buildUrl(path);
+    const response = await this.makeRequest(url, {
+      method: "DELETE",
+      headers: this.headers
+    });
+    return this.transformResponse(response);
+  }
   /**
    * Generic request that returns raw Response for streaming
    */
@@ -1826,6 +2037,7 @@ var RuntypeClient = class {
   /**
    * Build full URL with query parameters
    */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- mirrors get()'s permissive params type
   buildUrl(path, params) {
     const base = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
     const relPath = path.startsWith("/") ? path.slice(1) : path;
@@ -2051,6 +2263,25 @@ var Runtype = class {
   static get prompts() {
     return new PromptsNamespace(() => this.getClient());
   }
+  /**
+   * Skills namespace - Manage Agent Skills (admin/control plane)
+   *
+   * @example
+   * ```typescript
+   * // Create a published skill from a SKILL.md document
+   * const { skill } = await Runtype.skills.create({ markdown: skillMd, publish: true })
+   *
+   * // Bind it to an agent
+   * await Runtype.skills.bind({ agentId: 'agent_123', skillId: skill.id })
+   *
+   * // Review agent-authored proposals
+   * const pending = await Runtype.skills.proposals.list()
+   * await Runtype.skills.proposals.approve(pending[0].id)
+   * ```
+   */
+  static get skills() {
+    return new SkillsNamespace(() => this.getClient());
+  }
 };
 
 // src/generated-tool-gate.ts
@@ -4243,12 +4474,6 @@ var ToolsEndpoint = class {
   async test(id, data) {
     return this.client.post(`/tools/${id}/test`, data);
   }
-  /**
-   * Get tool executions for a specific tool
-   */
-  async getExecutions(toolId, params) {
-    return this.client.get(`/tools/${toolId}/executions`, params);
-  }
   /**
    * Get AI SDK compatible tool schemas
    */
@@ -8292,7 +8517,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
@@ -8301,19 +8526,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":
@@ -8323,10 +8552,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;
               }
@@ -8334,7 +8563,7 @@ var RuntypeClient2 = class {
                 wrappedCallbacks.onFlowComplete?.(event);
                 break;
               case "flow_error":
-                wrappedCallbacks.onError?.(new Error(event.error));
+                wrappedCallbacks.onError?.(new Error(flowErrorMessage2(event)));
                 break;
             }
           }
@@ -9194,6 +9423,8 @@ var STEP_TYPE_TO_METHOD = {
   STEP_TYPE_TO_METHOD,
   SchedulesEndpoint,
   SecretsEndpoint,
+  SkillProposalsNamespace,
+  SkillsNamespace,
   SurfacesEndpoint,
   ToolsEndpoint,
   UsersEndpoint,