@theokit/sdk 2.10.0 → 2.11.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 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
+
+- ac3f77d: @theokit/sdk: resolveModelCapabilities catalog gains cheap OpenRouter slugs (qwen3-coder, deepseek v4-flash/v3.2, glm-4.7-flash, gemini-2.5-flash-lite/pro) so they resolve real context windows instead of the 4096 default. @theokit/sdk-tools: new createGenericHttpSearchAdapter (env-keyed generic HTTP WebSearchCallback alongside Brave); buildEnvContext gains git-branch detection + an injectable clock. @theokit/sdk-cache: ships createLexicalEmbedder (zero-dependency token-hash lexical embedder built-in).
+
 ## 2.10.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,12 @@ 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 } } : {};
+      })(),
       messages: ctx.messages,
       tools: ctx.tools.map(toLlmTool)
     },
@@ -7158,6 +7176,7 @@ function registerLoopError(ctx, cause) {
 }
 async function runCollectorLoop(generator, inputs, ctx) {
   let accumulatedText = "";
+  let reasoningText = "";
   let errored = false;
   let finishValue;
   while (true) {
@@ -7170,6 +7189,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 +7200,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 +7214,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 +10107,14 @@ 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 buildOpenAIBody(request, providerName) {
   const messages = [];
   const systemText = openAISystemText(request.system);
   if (systemText.length > 0) {
@@ -10091,6 +10133,8 @@ function buildOpenAIBody(request) {
   };
   if (request.maxTokens !== void 0) body.max_tokens = request.maxTokens;
   if (request.temperature !== void 0) body.temperature = request.temperature;
+  if (request.reasoning?.effort !== void 0)
+    applyReasoningRequest(body, request.reasoning.effort, providerName);
   if (request.tools !== void 0 && request.tools.length > 0) {
     body.tools = request.tools.map((tool) => ({
       type: "function",
@@ -10186,7 +10230,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 +10292,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 +10303,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 +11196,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),