@ai-sdk/harness-deepagents 1.0.69 → 1.0.71

package/src/deepagents-auth.ts

@@ -1,6 +1,11 @@
 import { getAiGatewayAuthFromEnv } from '@ai-sdk/harness/utils';
 
-export type DeepAgentsAuthOptions = {
+export type DeepAgentsAuthenticationMode = 'auto' | 'anthropic' | 'ai-gateway';
+
+/**
+ * @deprecated Passing an object to auth options is deprecated. Use a `DeepAgentsAuthenticationMode` string value ("auto" | "anthropic" | "ai-gateway") instead, and pass credentials via environment variables.
+ */
+export type LegacyDeepAgentsAuthOptions = {
   readonly anthropic?: {
     readonly apiKey?: string;
     readonly authToken?: string;
@@ -12,6 +17,10 @@ export type DeepAgentsAuthOptions = {
   };
 };
 
+export type DeepAgentsAuthOptions =
+  | DeepAgentsAuthenticationMode
+  | LegacyDeepAgentsAuthOptions;
+
 // DeepAgents always drives the Anthropic client. Non-Anthropic models reach it
 // through AI Gateway's Anthropic-compatible endpoint, which translates to any
 // model (Gemini, OpenAI, etc.), tool calls included.
@@ -22,13 +31,18 @@ export function resolveDeepAgentsEnv({
   auth?: DeepAgentsAuthOptions;
   processEnv?: Record<string, string | undefined>;
 }): Record<string, string> {
-  if (auth?.anthropic) {
-    return pickAnthropic({ explicit: auth.anthropic, processEnv });
+  const normalizedAuth = normalizeDeepAgentsAuthToLegacyAuth(auth);
+
+  if (normalizedAuth?.anthropic) {
+    return pickAnthropic({ explicit: normalizedAuth.anthropic, processEnv });
   }
 
   const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({ env: processEnv });
-  if (auth?.gateway) {
-    return pickGateway({ explicit: auth.gateway, gatewayAuthFromEnv });
+  if (normalizedAuth?.gateway) {
+    return pickGateway({
+      explicit: normalizedAuth.gateway,
+      gatewayAuthFromEnv,
+    });
   }
   if (gatewayAuthFromEnv.apiKey) {
     return pickGateway({ explicit: {}, gatewayAuthFromEnv });
@@ -37,11 +51,34 @@ export function resolveDeepAgentsEnv({
   return pickAnthropic({ processEnv });
 }
 
+function normalizeDeepAgentsAuthToLegacyAuth(
+  auth: DeepAgentsAuthOptions | undefined,
+): LegacyDeepAgentsAuthOptions | undefined {
+  if (auth == null || auth === 'auto') {
+    return undefined;
+  }
+  if (typeof auth === 'string') {
+    switch (auth) {
+      case 'anthropic':
+        return { anthropic: {} };
+      case 'ai-gateway':
+        return { gateway: {} };
+      default:
+        return undefined;
+    }
+  }
+
+  console.warn(
+    '[deepagents] Passing an object to auth options is deprecated. Use a string mode ("auto" | "anthropic" | "ai-gateway") instead, and pass credentials via environment variables.',
+  );
+  return auth;
+}
+
 function pickAnthropic({
   explicit,
   processEnv,
 }: {
-  explicit?: NonNullable<DeepAgentsAuthOptions['anthropic']>;
+  explicit?: NonNullable<LegacyDeepAgentsAuthOptions['anthropic']>;
   processEnv: Record<string, string | undefined>;
 }): Record<string, string> {
   const env: Record<string, string> = {};
@@ -58,7 +95,7 @@ function pickGateway({
   explicit,
   gatewayAuthFromEnv,
 }: {
-  explicit: NonNullable<DeepAgentsAuthOptions['gateway']>;
+  explicit: NonNullable<LegacyDeepAgentsAuthOptions['gateway']>;
   gatewayAuthFromEnv: ReturnType<typeof getAiGatewayAuthFromEnv>;
 }): Record<string, string> {
   const apiKey = explicit.apiKey ?? gatewayAuthFromEnv.apiKey;

package/src/deepagents-bridge-protocol.ts

@@ -10,6 +10,19 @@ import { z } from 'zod/v4';
 export const outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
 export type OutboundMessage = z.infer<typeof outboundMessageSchema>;
 
+const thinkingSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal('adaptive'),
+    display: z.enum(['summarized', 'omitted']).optional(),
+  }),
+  z.object({
+    type: z.literal('enabled'),
+    budget_tokens: z.number(),
+    display: z.enum(['summarized', 'omitted']).optional(),
+  }),
+  z.object({ type: z.literal('disabled') }),
+]);
+
 export const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
   mcpServers: z.record(z.string(), z.unknown()).optional(),
   /*
@@ -17,6 +30,8 @@ export const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
    * the session's agent.
    */
   instructions: z.string().optional(),
+  thinking: thinkingSchema.optional(),
+  effort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional(),
   // In-backend skills source dirs ($HOME and <workDir>), passed to createDeepAgent({ skills }).
   skillsPaths: z.array(z.string()).optional(),
   // Max LangGraph super-steps per turn (streamEvents recursionLimit).

package/src/deepagents-harness.ts

@@ -59,6 +59,20 @@ const BOOTSTRAP_DIR = '.harness-bootstrap/deepagents';
  */
 const DEEPAGENTS_CLIENT_APP = `ai-sdk/harness-deepagents/${VERSION}`;
 
+export type DeepAgentsThinkingConfig =
+  | {
+      readonly type: 'adaptive';
+      readonly display?: 'summarized' | 'omitted';
+    }
+  | {
+      readonly type: 'enabled';
+      readonly budget_tokens: number;
+      readonly display?: 'summarized' | 'omitted';
+    }
+  | {
+      readonly type: 'disabled';
+    };
+
 // Pinned ripgrep release + per-arch tarball checksums (verified before install).
 const RIPGREP_VERSION = '14.1.1';
 const RIPGREP_SHA256_X64 =
@@ -92,6 +106,16 @@ export type DeepAgentsHarnessSettings = {
   readonly auth?: DeepAgentsAuthOptions;
   /** Model id for the DeepAgents runtime, e.g. `claude-sonnet-4` (converted to `provider:model`). */
   readonly model?: string;
+  /**
+   * Controls Anthropic extended thinking for the Deep Agents model. Unset
+   * preserves the Deep Agents runtime default.
+   */
+  readonly thinking?: DeepAgentsThinkingConfig;
+  /**
+   * Controls how much effort Claude applies when adaptive thinking is enabled.
+   * Unset uses the LangChain Anthropic client default.
+   */
+  readonly effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
   /** Bridge port override; defaults to the sandbox's first declared port. */
   readonly port?: number;
   /** Maximum milliseconds to wait for the bridge to advertise its port. Defaults to 120000. */
@@ -280,6 +304,8 @@ export function createDeepAgents(
             channel: attachChannel,
             proc: undefined,
             model: settings.model,
+            thinking: settings.thinking,
+            effort: settings.effort,
             bridgePort: coords.port,
             bridgeToken: coords.token,
             sandboxId,
@@ -397,6 +423,8 @@ export function createDeepAgents(
         channel,
         proc,
         model: settings.model,
+        thinking: settings.thinking,
+        effort: settings.effort,
         bridgePort: boundPort,
         bridgeToken: token,
         sandboxId,
@@ -496,6 +524,8 @@ function createSession({
   channel,
   proc,
   model,
+  thinking,
+  effort,
   bridgePort,
   bridgeToken,
   sandboxId,
@@ -512,6 +542,8 @@ function createSession({
   // Undefined on attach — the live bridge was spawned by another process.
   proc: Experimental_SandboxProcess | undefined;
   model: string | undefined;
+  thinking: DeepAgentsThinkingConfig | undefined;
+  effort: 'low' | 'medium' | 'high' | 'xhigh' | 'max' | undefined;
   bridgePort: number;
   bridgeToken: string;
   sandboxId: string;
@@ -678,6 +710,8 @@ function createSession({
           inputSchema: t.inputSchema,
         })),
         ...(model ? { model } : {}),
+        ...(thinking ? { thinking } : {}),
+        ...(effort ? { effort } : {}),
         ...(skillsPaths?.length ? { skillsPaths } : {}),
         ...(permissionMode ? { permissionMode } : {}),
         ...(builtinToolFiltering ? { builtinToolFiltering } : {}),

package/src/index.ts

@@ -5,5 +5,11 @@ export const deepAgents = createDeepAgents();
 
 export { createDeepAgents } from './deepagents-harness';
 export { VERSION } from './version';
-export type { DeepAgentsHarnessSettings } from './deepagents-harness';
-export type { DeepAgentsAuthOptions } from './deepagents-auth';
+export type {
+  DeepAgentsHarnessSettings,
+  DeepAgentsThinkingConfig,
+} from './deepagents-harness';
+export type {
+  DeepAgentsAuthenticationMode,
+  DeepAgentsAuthOptions,
+} from './deepagents-auth';