@theokit/sdk 2.11.0 → 2.11.2

package/dist/a2a/index.js

@@ -6886,6 +6886,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 });
@@ -7071,6 +7079,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",
@@ -7087,6 +7099,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)
     },
@@ -7155,6 +7176,7 @@ function registerLoopError(ctx, cause) {
 }
 async function runCollectorLoop(generator, inputs, ctx) {
   let accumulatedText = "";
+  let reasoningText = "";
   let errored = false;
   let finishValue;
   while (true) {
@@ -7167,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 = "";
@@ -7174,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) {
@@ -7185,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();
@@ -10069,7 +10107,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) {
@@ -10088,12 +10141,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;
@@ -10183,7 +10233,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({
@@ -10245,6 +10295,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);
@@ -10252,6 +10306,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;
@@ -11141,7 +11199,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),
@@ -11151,6 +11214,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(