agent-accelerator 0.5.0 → 0.5.2

package/src/agent/loop.ts

@@ -20,7 +20,6 @@ import {
   traceToolEvent,
 } from "../tools/executor.ts";
 import { getModelFromCatalog, ensureModelCatalogFresh, validateModelThinking } from "../models/catalog.ts";
-import { preprocessFilePartsForBypass } from "../utils/documents.ts";
 import { enforceFileAccess } from "../utils/safe-io.ts";
 import { isSubagentResult, normalizeSubagentMetadata } from "../tools/subagent-result.ts";
 import { BudgetExceededError } from "../types/errors.ts";
@@ -49,8 +48,6 @@ export interface AgentLoopConfig {
   options?: ProviderRequestOptions;
   runOptions?: AgentRunOptions;
   maxTurns?: number;
-  /** Convert `file` parts client-side for pdf-incapable models (see Agent flag). */
-  bypassInputFileModality?: boolean;
   /** Local-file policy: media paths must resolve inside `roots` (see `AgentConfig.fileAccess`). */
   fileAccess?: { roots?: string[] };
   /**
@@ -343,8 +340,7 @@ function loopSessionId(config: AgentLoopConfig): string | undefined {
   try {
     return (
       (config.runOptions as { sessionId?: string } | undefined)?.sessionId ||
-      (config.options as { sessionId?: string } | undefined)?.sessionId ||
-      (config.options as { cache?: { sessionId?: string } } | undefined)?.cache?.sessionId
+      (config.options as { sessionId?: string } | undefined)?.sessionId
     );
   } catch { return undefined; }
 }
@@ -622,15 +618,6 @@ export async function runAgentLoop(config: AgentLoopConfig): Promise<AgentRespon
   const repeatCounts = new Map<string, number>();
 
   try {
-  if (config.bypassInputFileModality) {
-    await preprocessFilePartsForBypass(config.context.messages, {
-      providerId: provider.id,
-      modelId,
-      signal: runOptions?.signal,
-      roots: config.fileAccess?.roots,
-    });
-  }
-
   const standardTools = toStandardToolDeclarations(tools);
 
   while (turns < maxTurns) {
@@ -647,8 +634,7 @@ export async function runAgentLoop(config: AgentLoopConfig): Promise<AgentRespon
 
     const providerOptions: ProviderRequestOptions = {
       ...options,
-      // Merge sessionId from cache or top-level (C4 fix: read both)
-      sessionId: runOptions?.sessionId || options?.sessionId || options?.cache?.sessionId,
+      sessionId: runOptions?.sessionId || options?.sessionId,
       cache: options?.cache,
       tools: standardTools.length > 0 ? standardTools : undefined,
       signal: runOptions?.signal,
@@ -680,31 +666,30 @@ export async function runAgentLoop(config: AgentLoopConfig): Promise<AgentRespon
       if (gTier === "paid" || gTier === "free") providerOptions.googleTier = gTier;
     } catch {}
 
+    // A long-running call (e.g. Google long decode) times each HTTP request itself: no whole-call race.
+    const longRunning = provider.isLongRunning?.(modelId, providerOptions) === true;
     const genResult = await generateWithTimeout(
       () => provider.generate(
         modelId,
         {
           systemPrompt: context.systemPrompt,
           messages: context.messages,
-          cachedContentId: context.cachedContentId,
         },
         providerOptions
       ),
-      limits.requestTimeoutMs
+      longRunning ? Infinity : limits.requestTimeoutMs
     );
 
     finalResult = genResult;
 
     // Canonical session routing: lets adapters detect provider switches.
     noteProviderTurn(
-      runOptions?.sessionId || options?.sessionId || options?.cache?.sessionId,
+      runOptions?.sessionId || options?.sessionId,
       provider.id
     );
 
-    // Thinking is exposed via events/traces and onTurn (see shouldExposeThinking,
-    // default true). Promoting thinking to answer text is gated (Q-15, default
-    // OFF): without the explicit opt-in the run returns the provider's empty
-    // text with its finishReason instead of fabricating an answer from reasoning.
+    // Thinking is exposed via events/traces and onTurn. Promoting it to answer text is gated (Q-15,
+    // default OFF): without the opt-in the run returns the provider's empty text and finishReason.
     if ((!genResult.text || genResult.text.trim() === "") && (!genResult.toolCalls || genResult.toolCalls.length === 0) && genResult.thinking) {
       if (shouldPromoteThinkingToAnswer(config, runOptions)) {
         if (genResult.thinking.includes("</think>")) {
@@ -727,7 +712,8 @@ export async function runAgentLoop(config: AgentLoopConfig): Promise<AgentRespon
       genResult.text,
       genResult.toolCalls,
       genResult.thinking,
-      genResult.thoughtSignature
+      genResult.thoughtSignature,
+      genResult.providerSteps
     );
 
     // Thinking-trace telemetry (observability-only, full text, no limit):
@@ -742,7 +728,7 @@ export async function runAgentLoop(config: AgentLoopConfig): Promise<AgentRespon
             turns,
             model: modelId,
             provider: provider.id,
-            sessionId: runOptions?.sessionId || options?.sessionId || options?.cache?.sessionId,
+            sessionId: runOptions?.sessionId || options?.sessionId,
             thinking: genResult.thinking,
             ...(genResult.thoughtSignature ? { thoughtSignature: genResult.thoughtSignature } : {}),
           },
@@ -763,14 +749,6 @@ export async function runAgentLoop(config: AgentLoopConfig): Promise<AgentRespon
       emitTurn(runOptions, { turns, text: genResult.text, thinking: genResult.thinking });
       if (noToolSteered.length > 0) {
         try { config.onSteerInjected?.(noToolSteered); } catch {}
-        if (config.bypassInputFileModality) {
-          await preprocessFilePartsForBypass(config.context.messages, {
-            providerId: provider.id,
-            modelId,
-            signal: runOptions?.signal,
-            roots: config.fileAccess?.roots,
-          });
-        }
       }
       emitProgress(config);
       if (noToolSteered.length > 0) continue;
@@ -795,7 +773,7 @@ export async function runAgentLoop(config: AgentLoopConfig): Promise<AgentRespon
       repeatCounts,
       agentName,
       signal: runOptions?.signal,
-      sessionId: runOptions?.sessionId || options?.sessionId || options?.cache?.sessionId,
+      sessionId: runOptions?.sessionId || options?.sessionId,
     });
     const results = guarded.results;
     previousToolCallFingerprints = guarded.fingerprints;
@@ -839,14 +817,6 @@ export async function runAgentLoop(config: AgentLoopConfig): Promise<AgentRespon
     const toolSteered = drainSteerInbox(context, config.steerInbox);
     if (toolSteered.length > 0) {
       try { config.onSteerInjected?.(toolSteered); } catch {}
-      if (config.bypassInputFileModality) {
-        await preprocessFilePartsForBypass(config.context.messages, {
-          providerId: provider.id,
-          modelId,
-          signal: runOptions?.signal,
-          roots: config.fileAccess?.roots,
-        });
-      }
     }
     emitProgress(config);
 
@@ -1005,14 +975,6 @@ export function streamAgentLoop(config: AgentLoopConfig): AssistantMessageEventS
           }
         }
       }
-      if (config.bypassInputFileModality) {
-        await preprocessFilePartsForBypass(config.context.messages, {
-          providerId: config.provider.id,
-          modelId: config.modelId,
-          signal: config.runOptions?.signal,
-          roots: config.fileAccess?.roots,
-        });
-      }
       const {
         agentName,
         provider,
@@ -1067,7 +1029,7 @@ export function streamAgentLoop(config: AgentLoopConfig): AssistantMessageEventS
 
         const providerOptions: ProviderRequestOptions = {
           ...options,
-          sessionId: runOptions?.sessionId || options?.sessionId || options?.cache?.sessionId,
+          sessionId: runOptions?.sessionId || options?.sessionId,
           cache: options?.cache,
           tools: standardTools.length > 0 ? standardTools : undefined,
           signal: linked.signal,
@@ -1094,12 +1056,12 @@ export function streamAgentLoop(config: AgentLoopConfig): AssistantMessageEventS
           if (gTier === "paid" || gTier === "free") providerOptions.googleTier = gTier;
         } catch {}
 
+        const longRunning = provider.isLongRunning?.(modelId, providerOptions) === true;
         const innerStream = provider.stream(
           modelId,
           {
             systemPrompt: context.systemPrompt,
             messages: context.messages,
-            cachedContentId: context.cachedContentId,
           },
           providerOptions
         );
@@ -1113,7 +1075,8 @@ export function streamAgentLoop(config: AgentLoopConfig): AssistantMessageEventS
           let first = true;
           let doneIter = false;
           while (!doneIter) {
-            const waitMs = first ? streamLimits.firstByteTimeoutMs : streamLimits.streamIdleTimeoutMs;
+            // Long-running streams pause for minutes between chunks; the adapter guards stalls and reconnects.
+            const waitMs = longRunning ? Infinity : first ? streamLimits.firstByteTimeoutMs : streamLimits.streamIdleTimeoutMs;
             let timer: ReturnType<typeof setTimeout> | undefined;
             const timeoutP =
               Number.isFinite(waitMs) && waitMs !== Infinity && waitMs > 0
@@ -1161,7 +1124,7 @@ export function streamAgentLoop(config: AgentLoopConfig): AssistantMessageEventS
         lastResponse = turnResponse;
         // Canonical session routing: lets adapters detect provider switches.
         noteProviderTurn(
-          runOptions?.sessionId || options?.sessionId || options?.cache?.sessionId,
+          runOptions?.sessionId || options?.sessionId,
           provider.id
         );
 
@@ -1189,7 +1152,8 @@ export function streamAgentLoop(config: AgentLoopConfig): AssistantMessageEventS
           turnResponse.text,
           turnResponse.toolCalls,
           turnResponse.thinking,
-          turnResponse.thoughtSignature
+          turnResponse.thoughtSignature,
+          turnResponse.providerSteps
         );
 
         // Thinking-trace telemetry (observability-only, full text, no limit):
@@ -1203,7 +1167,7 @@ export function streamAgentLoop(config: AgentLoopConfig): AssistantMessageEventS
                 turns,
                 model: modelId,
                 provider: provider.id,
-                sessionId: runOptions?.sessionId || options?.sessionId || options?.cache?.sessionId,
+                sessionId: runOptions?.sessionId || options?.sessionId,
                 thinking: turnResponse.thinking,
                 ...(turnResponse.thoughtSignature ? { thoughtSignature: turnResponse.thoughtSignature } : {}),
               },
@@ -1254,7 +1218,7 @@ export function streamAgentLoop(config: AgentLoopConfig): AssistantMessageEventS
       repeatCounts,
           agentName,
           signal: linked.signal,
-          sessionId: runOptions?.sessionId || options?.sessionId || options?.cache?.sessionId,
+          sessionId: runOptions?.sessionId || options?.sessionId,
           onSubagentEvent: (ev) => {
             try {
               outerStream.push({
@@ -1452,36 +1416,10 @@ export function streamAgentLoop(config: AgentLoopConfig): AssistantMessageEventS
 }
 
 // ---------------------------------------------------------------------------
-// Q-15: single thinking-exposure policy + Q-04 canonical finish helper.
+// Q-15: thinking-promotion policy + Q-04 canonical finish helper.
 // (Appended here to avoid conflicts with other loop sections.)
 // ---------------------------------------------------------------------------
 
-/**
- * Single expose-thinking policy (Q-15).
- * - Events/traces/onTurn always carry thinking separately (default true).
- * - Promoting thinking to answer *text* is a separate opt-in
- *   (`thinkingAsAnswerFallback`, default false) — see
- *   `shouldPromoteThinkingToAnswer`.
- *
- * Reads `exposeThinking` from the loop config, run options, or provider
- * options; any explicit `false` hides thinking from events/traces.
- */
-export function shouldExposeThinking(config?: unknown): boolean {
-  try {
-    const c = config as {
-      exposeThinking?: unknown;
-      runOptions?: { exposeThinking?: unknown };
-      options?: { exposeThinking?: unknown };
-    } | null | undefined;
-    const v = c?.exposeThinking ?? c?.runOptions?.exposeThinking ?? c?.options?.exposeThinking;
-    if (v === undefined) return true;
-    return Boolean(v);
-  } catch {
-    // why: policy lookup is best-effort — default to exposing thinking.
-    return true;
-  }
-}
-
 /**
  * Whether an empty-text turn may promote `thinking` to answer `text` (Q-15).
  * Default false: the run returns the provider's empty text with its

package/src/agent/subagent.ts

@@ -59,7 +59,7 @@ export function agentFromEnv(
 export class SubAgent extends Agent {
   /**
    * Creates a delegated worker, defaulting to `SUB_AGENT_MODEL` or `MODEL`
-   * when `model` is omitted, and retaining short-lived cache state by default.
+   * when `model` is omitted.
    *
    * @param config Worker configuration. It accepts the same options as `Agent`
    * and can be registered with a parent via `subagents`.
@@ -83,7 +83,6 @@ export class SubAgent extends Agent {
     super({
       ...config,
       model: resolvedModel,
-      cache: config.cache ?? { retention: "short" },
     });
   }
 

package/src/agent/worker.ts

@@ -99,8 +99,7 @@ export function resolveMainModel(configModel: AgentConfig["model"]): {
  * Unwraps `ModelProviderInstance` / `ModelSpec` the same way.
  */
 export function resolveDynamicWorkerModel(
-  dynModelRawInput: unknown,
-  subagentModelInput: unknown
+  dynModelRawInput: unknown
 ): string | Record<string, unknown> | undefined {
   const dynModelRaw = dynModelRawInput as
     | { model?: unknown; id?: unknown; provider?: unknown }
@@ -119,7 +118,6 @@ export function resolveDynamicWorkerModel(
   } else {
     dynModel = (dynModelRaw as string | undefined) || getSubModel() as string | undefined;
   }
-  void subagentModelInput;
   return dynModel;
 }
 
@@ -133,7 +131,7 @@ export function resolveDynamicModelInput(
   subagentModel: unknown
 ): string | Record<string, unknown> | undefined {
   const dynModelRaw = (dynamicSubagents as { model?: unknown } | undefined)?.model ?? subagentModel;
-  return resolveDynamicWorkerModel(dynModelRaw, subagentModel);
+  return resolveDynamicWorkerModel(dynModelRaw);
 }
 
 /**
@@ -337,7 +335,6 @@ export function createLiveWorker(
   hooks: LiveWorkerHooks = {}
 ): {
   onWorkerTurn: (turn: LiveWorkerTurn) => void;
-  onWorkerDelta: (delta?: string, thinkingDelta?: string) => void;
   attachToStream: (workerStream: {
     on: (event: string, listener: (e: { delta?: string; thinkingDelta?: string }) => void) => void;
     off: (event: string, listener: (e: { delta?: string; thinkingDelta?: string }) => void) => void;
@@ -431,5 +428,5 @@ export function createLiveWorker(
     };
   };
 
-  return { onWorkerTurn, onWorkerDelta, attachToStream };
+  return { onWorkerTurn, attachToStream };
 }

package/src/index.ts

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import type { AssistantMessageEventStream as AssistantMessageEventStreamT } from "./streaming/event-stream.ts";
 import type { AgentResponse as AgentResponseT } from "./types/response.ts";
 
@@ -56,23 +55,6 @@ export { zodToJsonSchema, cleanJsonSchema } from "./tools/schema.ts";
  */
 export { executeToolCalls } from "./tools/executor.ts";
 
-// Client-side document conversion (optional anydoc peer — see utils/documents.ts)
-export {
-  convertDocumentToMarkdown,
-  convertDocumentInput,
-  convert_document_to_markdown,
-  createConvertDocumentTool,
-  isAnydocAvailable,
-  resolveDocumentFormat,
-  truncateMarkdown,
-  buildDocumentXml,
-  modelSupportsFileInput,
-  preprocessFilePartsForBypass,
-  DocumentConversionError,
-  DEFAULT_DOCUMENT_MAX_CHARS,
-  MAX_DOCUMENT_FETCH_BYTES,
-} from "./utils/documents.ts";
-export type { ConvertDocumentOptions, ConvertedDocument, ConvertDocumentToolOptions } from "./utils/documents.ts";
 export { assertPathAllowed, enforceFileAccess, fetchRemoteBytes, isPrivateAddress, RemoteFetchError, MAX_REMOTE_FETCH_BYTES } from "./utils/safe-io.ts";
 
 // Multi-Agent Delegation & Tools
@@ -223,17 +205,14 @@ export {
   clearSessionRouting,
   mapThinkingLevelToGoogle,
   mapServiceTierToGoogle,
-  applyCacheForGoogle,
   mapThinkingLevelToOpenRouter,
   mapServiceTierToOpenRouter,
-  applyCacheForOpenRouter,
   mapToolChoiceToOpenRouter,
   mapThinkingLevelToOpenRouterChat,
   mapToolChoiceToOpenRouterChat,
   mapThinkingLevelToOpenAI,
   mapServiceTierToOpenAI,
-  applyCacheForOpenAI,
-  applyCacheForCustom,
+  resolveCache,
   mapToolChoiceToOpenAI,
   normalizeToolChoice,
   parseStreamedToolArguments,
@@ -278,16 +257,7 @@ export {
 
 export { stripSchemaForGoogle } from "./tools/schema.ts";
 
-export {
-  createExplicitCache,
-  retentionToTtlSeconds,
-  getPromptCacheRetention,
-  clampCacheKey,
-} from "./utils/cache.ts";
-export type {
-  CreateExplicitCacheOptions,
-  CachedContentMetadata,
-} from "./utils/cache.ts";
+export { clampCacheKey } from "./utils/cache.ts";
 
 // Streaming & Events
 export { AssistantMessageEventStream } from "./streaming/event-stream.ts";
@@ -368,20 +338,13 @@ export { normalizeMediaInput, inferMimeType, sniffMimeType } from "./utils/media
 export { base64ToBytes, bytesToBase64 } from "./utils/base64.ts";
 export { toJsonSafe, safeStringify, escapeXml } from "./utils/serialization.ts";
 
-// Re-export Zod (compat only)
-/**
- * @deprecated Compat re-export: prefer adding `zod` as a direct (peer)
- * dependency and importing from `"zod"` (Q-50). Kept so existing
- * `import { z } from "agent-accelerator"` code keeps working.
- */
-export { z };
+export { CACHE_OPTIONS } from "./types/core.ts";
 
 // TypeScript Type Exports
 export type {
   ThinkingLevel,
   ThinkingConfig,
-  CacheRetention,
-  CacheConfig,
+  CacheOption,
   ServiceTier,
   TokenUsage,
 } from "./types/core.ts";
@@ -399,6 +362,8 @@ export type {
   ToolResultPart,
   ThinkingPart,
   ProviderContext,
+  ProviderSteps,
+  MediaResolution,
 } from "./types/message.ts";
 
 export type {