Add CallSettings properties to DurableAgent

Copilot · pranaygp · Copilot · commit e99d33117349 · 2025-11-07T08:07:16.000Z
Port easier properties from AI SDK Agent class (temperature, maxOutputTokens, topP, topK, presencePenalty, frequencyPenalty, stopSequences, seed) to bring DurableAgent closer to functional parity with ToolLoopAgent/Agent class.

Co-authored-by: pranaygp &lt;1797812+pranaygp@users.noreply.github.com&gt;
diff --git a/packages/ai/src/agent/do-stream-step.ts b/packages/ai/src/agent/do-stream-step.ts
@@ -12,14 +12,32 @@ export async function doStreamStep(
   conversationPrompt: LanguageModelV2Prompt,
   modelId: string,
   writable: WritableStream<UIMessageChunk>,
-  tools?: LanguageModelV2CallOptions['tools']
+  tools?: LanguageModelV2CallOptions['tools'],
+  callOptions?: {
+    temperature?: number;
+    maxOutputTokens?: number;
+    topP?: number;
+    topK?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    stopSequences?: string[];
+    seed?: number;
+  }
 ) {
   'use step';
 
   const model = gateway(modelId);
   const result = await model.doStream({
     prompt: conversationPrompt,
     tools,
+    temperature: callOptions?.temperature,
+    maxOutputTokens: callOptions?.maxOutputTokens,
+    topP: callOptions?.topP,
+    topK: callOptions?.topK,
+    presencePenalty: callOptions?.presencePenalty,
+    frequencyPenalty: callOptions?.frequencyPenalty,
+    stopSequences: callOptions?.stopSequences,
+    seed: callOptions?.seed,
   });
 
   let finish: FinishPart | undefined;
diff --git a/packages/ai/src/agent/durable-agent.test.ts b/packages/ai/src/agent/durable-agent.test.ts
@@ -0,0 +1,169 @@
+/**
+ * Tests for DurableAgent
+ *
+ * These tests verify that the DurableAgent constructor properly accepts
+ * and stores configuration options from the AI SDK Agent class.
+ */
+import { describe, expect, it } from 'vitest';
+import { DurableAgent } from './durable-agent.js';
+
+describe('DurableAgent', () => {
+  describe('constructor', () => {
+    it('should accept basic required options', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+      });
+
+      expect(agent).toBeDefined();
+    });
+
+    it('should accept system prompt', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+        system: 'You are a helpful assistant.',
+      });
+
+      expect(agent).toBeDefined();
+    });
+
+    it('should accept temperature option', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+        temperature: 0.7,
+      });
+
+      expect(agent).toBeDefined();
+    });
+
+    it('should accept maxOutputTokens option', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+        maxOutputTokens: 1000,
+      });
+
+      expect(agent).toBeDefined();
+    });
+
+    it('should accept topP option', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+        topP: 0.9,
+      });
+
+      expect(agent).toBeDefined();
+    });
+
+    it('should accept topK option', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+        topK: 40,
+      });
+
+      expect(agent).toBeDefined();
+    });
+
+    it('should accept presencePenalty option', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+        presencePenalty: 0.5,
+      });
+
+      expect(agent).toBeDefined();
+    });
+
+    it('should accept frequencyPenalty option', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+        frequencyPenalty: 0.5,
+      });
+
+      expect(agent).toBeDefined();
+    });
+
+    it('should accept stopSequences option', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+        stopSequences: ['STOP', 'END'],
+      });
+
+      expect(agent).toBeDefined();
+    });
+
+    it('should accept seed option', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+        seed: 12345,
+      });
+
+      expect(agent).toBeDefined();
+    });
+
+    it('should accept all options together', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+        system: 'You are a helpful assistant.',
+        temperature: 0.7,
+        maxOutputTokens: 1000,
+        topP: 0.9,
+        topK: 40,
+        presencePenalty: 0.5,
+        frequencyPenalty: 0.3,
+        stopSequences: ['STOP', 'END'],
+        seed: 12345,
+      });
+
+      expect(agent).toBeDefined();
+    });
+
+    it('should accept tools with proper structure', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {
+          testTool: {
+            description: 'A test tool',
+            inputSchema: {
+              type: 'object',
+              properties: {},
+            },
+            execute: async () => 'result',
+          },
+        },
+      });
+
+      expect(agent).toBeDefined();
+    });
+  });
+
+  describe('methods', () => {
+    it('should have generate method', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+      });
+
+      expect(agent.generate).toBeDefined();
+      expect(typeof agent.generate).toBe('function');
+    });
+
+    it('should have stream method', () => {
+      const agent = new DurableAgent({
+        model: 'anthropic/claude-opus',
+        tools: {},
+      });
+
+      expect(agent.stream).toBeDefined();
+      expect(typeof agent.stream).toBe('function');
+    });
+  });
+});
diff --git a/packages/ai/src/agent/durable-agent.ts b/packages/ai/src/agent/durable-agent.ts
@@ -33,6 +33,67 @@ export interface DurableAgentOptions {
    * Optional system prompt to guide the agent's behavior.
    */
   system?: string;
+
+  /**
+   * Temperature setting. The range depends on the provider and model.
+   *
+   * It is recommended to set either `temperature` or `topP`, but not both.
+   */
+  temperature?: number;
+
+  /**
+   * Maximum number of tokens to generate.
+   */
+  maxOutputTokens?: number;
+
+  /**
+   * Nucleus sampling. This is a number between 0 and 1.
+   *
+   * E.g. 0.1 would mean that only tokens with the top 10% probability mass
+   * are considered.
+   *
+   * It is recommended to set either `temperature` or `topP`, but not both.
+   */
+  topP?: number;
+
+  /**
+   * Only sample from the top K options for each subsequent token.
+   *
+   * Used to remove "long tail" low probability responses.
+   * Recommended for advanced use cases only. You usually only need to use temperature.
+   */
+  topK?: number;
+
+  /**
+   * Presence penalty setting. It affects the likelihood of the model to
+   * repeat information that is already in the prompt.
+   *
+   * The presence penalty is a number between -1 (increase repetition)
+   * and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+   */
+  presencePenalty?: number;
+
+  /**
+   * Frequency penalty setting. It affects the likelihood of the model
+   * to repeatedly use the same words or phrases.
+   *
+   * The frequency penalty is a number between -1 (increase repetition)
+   * and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+   */
+  frequencyPenalty?: number;
+
+  /**
+   * Stop sequences.
+   * If set, the model will stop generating text when one of the stop sequences is generated.
+   * Providers may have limits on the number of stop sequences.
+   */
+  stopSequences?: string[];
+
+  /**
+   * The seed (integer) to use for random sampling. If set and supported
+   * by the model, calls will generate deterministic results.
+   */
+  seed?: number;
 }
 
 /**
@@ -92,11 +153,27 @@ export class DurableAgent {
   private model: string;
   private tools: ToolSet;
   private system?: string;
+  private temperature?: number;
+  private maxOutputTokens?: number;
+  private topP?: number;
+  private topK?: number;
+  private presencePenalty?: number;
+  private frequencyPenalty?: number;
+  private stopSequences?: string[];
+  private seed?: number;
 
   constructor(options: DurableAgentOptions) {
     this.model = options.model;
     this.tools = options.tools;
     this.system = options.system;
+    this.temperature = options.temperature;
+    this.maxOutputTokens = options.maxOutputTokens;
+    this.topP = options.topP;
+    this.topK = options.topK;
+    this.presencePenalty = options.presencePenalty;
+    this.frequencyPenalty = options.frequencyPenalty;
+    this.stopSequences = options.stopSequences;
+    this.seed = options.seed;
   }
 
   generate() {
@@ -124,6 +201,14 @@ export class DurableAgent {
       tools: this.tools,
       writable,
       prompt: modelPrompt,
+      temperature: this.temperature,
+      maxOutputTokens: this.maxOutputTokens,
+      topP: this.topP,
+      topK: this.topK,
+      presencePenalty: this.presencePenalty,
+      frequencyPenalty: this.frequencyPenalty,
+      stopSequences: this.stopSequences,
+      seed: this.seed,
     });
 
     let result = await iterator.next();
diff --git a/packages/ai/src/agent/stream-text-iterator.ts b/packages/ai/src/agent/stream-text-iterator.ts
@@ -13,11 +13,27 @@ export async function* streamTextIterator({
   tools = {},
   writable,
   model,
+  temperature,
+  maxOutputTokens,
+  topP,
+  topK,
+  presencePenalty,
+  frequencyPenalty,
+  stopSequences,
+  seed,
 }: {
   prompt: LanguageModelV2Prompt;
   tools: ToolSet;
   writable: WritableStream<UIMessageChunk>;
   model: string;
+  temperature?: number;
+  maxOutputTokens?: number;
+  topP?: number;
+  topK?: number;
+  presencePenalty?: number;
+  frequencyPenalty?: number;
+  stopSequences?: string[];
+  seed?: number;
 }): AsyncGenerator<
   LanguageModelV2ToolCall[],
   void,
@@ -31,7 +47,17 @@ export async function* streamTextIterator({
       conversationPrompt,
       model,
       writable,
-      toolsToModelTools(tools)
+      toolsToModelTools(tools),
+      {
+        temperature,
+        maxOutputTokens,
+        topP,
+        topK,
+        presencePenalty,
+        frequencyPenalty,
+        stopSequences,
+        seed,
+      }
     );
 
     if (finish?.finishReason === 'tool-calls') {
