@runtypelabs/sdk 1.15.3 → 1.17.0

package/dist/index.mjs

@@ -921,18 +921,19 @@ var RuntypeFlowBuilder = class {
         const { streamEvents: streamEvents2 } = await Promise.resolve().then(() => (init_stream_utils(), stream_utils_exports));
         try {
           for await (const event of streamEvents2(response)) {
-            if (event.type === "flow_await") {
+            const awaitEvent = event;
+            if (awaitEvent.type === "flow_await") {
               pausedState = {
-                toolName: event.toolName,
-                parameters: event.parameters,
-                executionId: event.executionId
+                toolName: awaitEvent.toolName || "",
+                parameters: awaitEvent.parameters,
+                executionId: awaitEvent.executionId || ""
               };
             }
-            if (event.type === "step_await") {
+            if (awaitEvent.type === "step_await") {
               pausedState = {
-                toolName: event.toolName,
-                parameters: event.parameters,
-                executionId: event.executionId
+                toolName: awaitEvent.toolName || "",
+                parameters: awaitEvent.parameters,
+                executionId: awaitEvent.executionId || ""
               };
             }
             switch (event.type) {
@@ -943,7 +944,7 @@ var RuntypeFlowBuilder = class {
                 wrappedCallbacks.onStepStart?.(event);
                 break;
               case "step_delta": {
-                const chunkText = event.chunk || event.text || "";
+                const chunkText = awaitEvent.chunk || awaitEvent.text || "";
                 wrappedCallbacks.onStepChunk?.(chunkText, event);
                 break;
               }
@@ -1001,8 +1002,9 @@ var RuntypeFlowBuilder = class {
           new Response(JSON.stringify(result), { headers: { "content-type": "application/json" } })
         );
       }
-      if (result.status === "paused" && result.pausedReason?.type === "local_action") {
-        const { toolName, parameters, executionId } = result.pausedReason;
+      const pausedResult = result;
+      if (pausedResult.status === "paused" && pausedResult.pausedReason?.type === "local_action") {
+        const { toolName, parameters, executionId } = pausedResult.pausedReason;
         if (!localTools[toolName]) {
           throw new Error(`Local tool "${toolName}" required but not provided in localTools map`);
         }
@@ -1457,6 +1459,21 @@ var PromptRunner = class {
     if (this.options.temperature !== void 0) {
       payload.temperature = this.options.temperature;
     }
+    if (this.options.topP !== void 0) {
+      payload.topP = this.options.topP;
+    }
+    if (this.options.topK !== void 0) {
+      payload.topK = this.options.topK;
+    }
+    if (this.options.frequencyPenalty !== void 0) {
+      payload.frequencyPenalty = this.options.frequencyPenalty;
+    }
+    if (this.options.presencePenalty !== void 0) {
+      payload.presencePenalty = this.options.presencePenalty;
+    }
+    if (this.options.seed !== void 0) {
+      payload.seed = this.options.seed;
+    }
     if (this.options.maxTokens !== void 0) {
       payload.maxTokens = this.options.maxTokens;
     }
@@ -7033,6 +7050,11 @@ var FlowBuilder = class {
         outputVariable: config.outputVariable,
         responseFormat: config.responseFormat,
         temperature: config.temperature,
+        topP: config.topP,
+        topK: config.topK,
+        frequencyPenalty: config.frequencyPenalty,
+        presencePenalty: config.presencePenalty,
+        seed: config.seed,
         maxTokens: config.maxTokens,
         reasoning: config.reasoning,
         streamOutput: config.streamOutput,
@@ -7361,6 +7383,103 @@ var FlowBuilder = class {
     return this;
   }
   // ============================================================================
+  // Subagent Helpers
+  // ============================================================================
+  /**
+   * Attach a subagent runtime tool to the most recent prompt step.
+   *
+   * A subagent tool spawns a focused child agent in its own context window
+   * when the parent's model calls it. The child runs with a whitelisted tool
+   * subset drawn from `allowedTools` (every entry must be available on the
+   * parent step). The parent only sees the child's final result.
+   *
+   * Pass either `agentId` (for a saved agent in the same org) or `agent`
+   * (an inline exported-agent JSON shape) — exactly one is required.
+   *
+   * @example
+   * ```typescript
+   * new FlowBuilder()
+   *   .createFlow({ name: 'Research' })
+   *   .prompt({ name: 'Plan', model: 'claude-sonnet-4-5', userPrompt: '...' })
+   *   .withSubagentTool('research_topic', {
+   *     agentId: 'agent_01h...',
+   *     allowedTools: ['builtin:exa_search'],
+   *     outputFormat: 'text',
+   *   })
+   * ```
+   */
+  withSubagentTool(name, opts) {
+    const lastStep = this.steps[this.steps.length - 1];
+    if (!lastStep || lastStep.type !== "prompt") {
+      throw new Error(
+        "withSubagentTool() must be called after a .prompt() step \u2014 it attaches a runtime tool to the last prompt step."
+      );
+    }
+    const config = {
+      agentId: opts.agentId,
+      agent: opts.agent,
+      allowedTools: opts.allowedTools,
+      maxTurns: opts.maxTurns,
+      maxCost: opts.maxCost,
+      timeoutMs: opts.timeoutMs,
+      outputFormat: opts.outputFormat,
+      inheritMessages: opts.inheritMessages,
+      taskTemplate: opts.taskTemplate
+    };
+    const tool = {
+      name,
+      description: opts.description ?? `Spawn the ${name} subagent for a focused sub-task. Returns only the subagent's final result.`,
+      toolType: "subagent",
+      parametersSchema: opts.parametersSchema ?? {
+        type: "object",
+        properties: {
+          task: {
+            type: "string",
+            description: "Self-contained task for the subagent. The subagent cannot see this conversation."
+          }
+        },
+        required: ["task"]
+      },
+      config
+    };
+    const existingTools = lastStep.config.tools ?? {};
+    const runtimeTools = [...existingTools.runtimeTools ?? [], tool];
+    lastStep.config.tools = { ...existingTools, runtimeTools };
+    return this;
+  }
+  /**
+   * Enable agent-driven dynamic subagent spawning on the most recent prompt
+   * step (surface C of the subagent design).
+   *
+   * When set, the API synthesizes a `spawn_subagent` tool the parent's model
+   * can call at runtime to spin off a focused child agent. The child's tools
+   * are drawn from `toolPool`, which must be a subset of the parent step's
+   * resolved tools. The API validates pool entries and rejects escalation.
+   *
+   * @example
+   * ```typescript
+   * new FlowBuilder()
+   *   .createFlow({ name: 'Explore' })
+   *   .prompt({ name: 'Research', model: 'claude-sonnet-4-5', userPrompt: '...' })
+   *   .withSubagents({
+   *     toolPool: ['builtin:exa_search', 'mcp:*'],
+   *     maxSpawnsPerRun: 3,
+   *     allowNesting: false,
+   *   })
+   * ```
+   */
+  withSubagents(opts) {
+    const lastStep = this.steps[this.steps.length - 1];
+    if (!lastStep || lastStep.type !== "prompt") {
+      throw new Error(
+        "withSubagents() must be called after a .prompt() step \u2014 it configures subagent spawning on the last prompt step."
+      );
+    }
+    const existingTools = lastStep.config.tools ?? {};
+    lastStep.config.tools = { ...existingTools, subagentConfig: opts };
+    return this;
+  }
+  // ============================================================================
   // Build Method
   // ============================================================================
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/sdk",
-  "version": "1.15.3",
+  "version": "1.17.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",