@theokit/sdk 2.11.0 → 2.11.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 2.11.2
+
+### Patch Changes
+
+- 8b411c5: Add `SendOptions.toolChoice` (`"auto" | "none" | "required"`), forwarded to the OpenAI/OpenRouter `tool_choice` request field. `"none"` forces a text answer even when the agent has tools registered — this lets an agent loop force a closing summary at its step ceiling (a cached agent's tools cannot be un-registered, so the gate must be applied per-send, not at agent creation). `tool_choice` is emitted only alongside a non-empty `tools` array. Additive and backward-compatible (absent ⇒ provider default).
+
+## 2.11.1
+
+### Patch Changes
+
+- 6893812: Forward `ModelSelection.params` reasoning to OpenRouter / OpenAI-compat providers (issue #47). The `thinking` param was silently dropped (model resolution kept only `model.id`; the request body had no `reasoning` field), so `Agent.send` never requested or surfaced reasoning. Now a `thinking` param maps to the reasoning request the target provider accepts — OpenRouter (and OpenAI-compatible passthroughs) use the unified `reasoning: { effort }` object, while native OpenAI Chat Completions uses the top-level `reasoning_effort` string (so opting into reasoning never 400s on api.openai.com). The streamed reasoning (`delta.reasoning`, or `delta.reasoning_content` on DeepSeek-direct / vLLM / LMStudio compat endpoints) is surfaced as `thinking-delta` `InteractionUpdate`s (live via `onDelta`) plus a `thinking` `SDKMessage` (replayed by `Run.stream`), on a separate channel from the visible answer. Validated end-to-end against `deepseek/deepseek-r1` via OpenRouter.
+
 ## 2.11.0
 
 ### Minor Changes

package/dist/a2a/index.cjs

@@ -6889,6 +6889,14 @@ function buildAssistantEvent(inputs, text) {
     message: { role: "assistant", content: [{ type: "text", text }] }
   };
 }
+function buildThinkingEvent(inputs, text) {
+  return {
+    type: "thinking",
+    agent_id: inputs.agentId,
+    run_id: inputs.runId,
+    text
+  };
+}
 function buildAssistantTurn(text, toolCalls) {
   const content = [];
   if (text.length > 0) content.push({ type: "text", text });
@@ -7074,6 +7082,10 @@ ${additions}`;
 function toLlmTool(tool) {
   return { name: tool.name, description: tool.description, inputSchema: tool.inputSchema };
 }
+function reasoningEffortFromParams(params) {
+  const thinking = params?.find((p) => p.id === "thinking");
+  return thinking !== void 0 && thinking.value.length > 0 ? thinking.value : void 0;
+}
 async function streamLlmTurn(inputs, ctx) {
   const llmSpan = inputs.telemetry?.startSpan("llm.call", {
     "model.id": inputs.model.id ?? "auto",
@@ -7090,6 +7102,15 @@ async function streamLlmTurn(inputs, ctx) {
         );
         return effective !== void 0 ? { system: effective } : {};
       })(),
+      // issue #47: forward the reasoning effort from ModelSelection.params (the `thinking` param)
+      // so the provider produces reasoning. Absent param ⇒ no `reasoning` field (bare request).
+      ...(() => {
+        const effort = reasoningEffortFromParams(inputs.model.params);
+        return effort !== void 0 ? { reasoning: { effort } } : {};
+      })(),
+      // Step-cap force-close: forward the per-run tool gate (`"none"` on a ceiling round forces a
+      // text close even though tools are advertised). Absent ⇒ provider default (auto).
+      ...inputs.toolChoice !== void 0 ? { toolChoice: inputs.toolChoice } : {},
       messages: ctx.messages,
       tools: ctx.tools.map(toLlmTool)
     },
@@ -7158,6 +7179,7 @@ function registerLoopError(ctx, cause) {
 }
 async function runCollectorLoop(generator, inputs, ctx) {
   let accumulatedText = "";
+  let reasoningText = "";
   let errored = false;
   let finishValue;
   while (true) {
@@ -7170,6 +7192,10 @@ async function runCollectorLoop(generator, inputs, ctx) {
       accumulatedText += next.value.text;
       await emitTextDeltaCallback(inputs, next.value.text);
     }
+    if (next.value.type === "reasoning_delta") {
+      reasoningText += next.value.text;
+      await emitReasoningDeltaCallback(inputs, next.value.text);
+    }
     if (next.value.type === "error") {
       registerLoopError(ctx, next.value);
       ctx.finalText = "";
@@ -7177,6 +7203,9 @@ async function runCollectorLoop(generator, inputs, ctx) {
       break;
     }
   }
+  if (reasoningText.length > 0) {
+    ctx.events.push(buildThinkingEvent(inputs, reasoningText));
+  }
   return { accumulatedText, errored, finishValue };
 }
 async function emitTextDeltaCallback(inputs, text) {
@@ -7188,6 +7217,15 @@ async function emitTextDeltaCallback(inputs, text) {
     "SendOptions.onDelta"
   );
 }
+async function emitReasoningDeltaCallback(inputs, text) {
+  if (inputs.onDelta === void 0) return;
+  const cb = inputs.onDelta;
+  await safeCall(
+    () => cb({ update: { type: "thinking-delta", text } }),
+    void 0,
+    "SendOptions.onDelta"
+  );
+}
 var init_loop_llm_stream = __esm({
   "src/internal/agent-loop/loop-llm-stream.ts"() {
     init_safe_call();
@@ -10072,7 +10110,22 @@ function mapOpenAIFinish(reason) {
       return "end_turn";
   }
 }
-function buildOpenAIBody(request) {
+function applyReasoningRequest(body, effort, providerName) {
+  if (providerName === "openai") {
+    body.reasoning_effort = effort;
+    return;
+  }
+  body.reasoning = { effort };
+}
+function applyToolsRequest(body, request) {
+  if (request.tools === void 0 || request.tools.length === 0) return;
+  body.tools = request.tools.map((tool) => ({
+    type: "function",
+    function: { name: tool.name, description: tool.description, parameters: tool.inputSchema }
+  }));
+  if (request.toolChoice !== void 0) body.tool_choice = request.toolChoice;
+}
+function buildOpenAIBody(request, providerName) {
   const messages = [];
   const systemText = openAISystemText(request.system);
   if (systemText.length > 0) {
@@ -10091,12 +10144,9 @@ function buildOpenAIBody(request) {
   };
   if (request.maxTokens !== void 0) body.max_tokens = request.maxTokens;
   if (request.temperature !== void 0) body.temperature = request.temperature;
-  if (request.tools !== void 0 && request.tools.length > 0) {
-    body.tools = request.tools.map((tool) => ({
-      type: "function",
-      function: { name: tool.name, description: tool.description, parameters: tool.inputSchema }
-    }));
-  }
+  if (request.reasoning?.effort !== void 0)
+    applyReasoningRequest(body, request.reasoning.effort, providerName);
+  applyToolsRequest(body, request);
   const responseFormat = encodeOpenAIResponseFormat(request.responseFormat);
   if (responseFormat !== void 0) body.response_format = responseFormat;
   return body;
@@ -10186,7 +10236,7 @@ var init_openai2 = __esm({
             method: "POST",
             signal,
             headers,
-            body: JSON.stringify(buildOpenAIBody(request))
+            body: JSON.stringify(buildOpenAIBody(request, providerId))
           });
         } catch (fetchErr) {
           const mapped = mapOllamaTransportError({
@@ -10248,6 +10298,10 @@ var init_openai2 = __esm({
         const events = [];
         this.applyUsage(chunk.usage);
         for (const choice of chunk.choices ?? []) {
+          const reasoningEvent = this.applyReasoningDelta(
+            choice.delta?.reasoning ?? choice.delta?.reasoning_content
+          );
+          if (reasoningEvent !== void 0) events.push(reasoningEvent);
           const textEvent = this.applyContentDelta(choice.delta?.content);
           if (textEvent !== void 0) events.push(textEvent);
           this.mergeToolCallDeltas(choice.delta?.tool_calls);
@@ -10255,6 +10309,10 @@ var init_openai2 = __esm({
         }
         return events;
       }
+      applyReasoningDelta(reasoning) {
+        if (typeof reasoning !== "string" || reasoning.length === 0) return void 0;
+        return { type: "reasoning_delta", text: reasoning };
+      }
       applyUsage(usage) {
         if (usage?.prompt_tokens !== void 0) this.inputTokens = usage.prompt_tokens;
         if (usage?.completion_tokens !== void 0) this.outputTokens = usage.completion_tokens;
@@ -11144,7 +11202,12 @@ function buildLoopInputs(options, runId, userText) {
   return {
     agentId: options.agentId,
     runId,
-    model: { id: effectiveModelId },
+    // issue #47: carry ModelSelection.params (the reasoning `thinking` param) into the loop so the
+    // request can forward reasoning. The id is stripped/normalized above; params pass through as-is.
+    model: {
+      id: effectiveModelId,
+      ...options.model?.params !== void 0 ? { params: options.model.params } : {}
+    },
     userMessage: userText,
     llm,
     mcp: buildMcpMap(options),
@@ -11154,6 +11217,7 @@ function buildLoopInputs(options, runId, userText) {
     ...options.systemPrompt !== void 0 ? { systemPrompt: options.systemPrompt } : {},
     ...options.onStep !== void 0 ? { onStep: options.onStep } : {},
     ...options.onDelta !== void 0 ? { onDelta: options.onDelta } : {},
+    ...options.sendOptions.toolChoice !== void 0 ? { toolChoice: options.sendOptions.toolChoice } : {},
     ...options.priorMessages !== void 0 ? { priorMessages: options.priorMessages } : {},
     ...options.memoryTools !== void 0 && options.memoryTools.length > 0 ? { memoryTools: options.memoryTools } : {},
     ...buildCustomToolsInput(