takos-control 1.0.0

package/src/application/services/agent/providers/llm-providers.ts

@@ -0,0 +1,484 @@
+/**
+ * Multi-Model Provider Abstraction
+ * Supports OpenAI, Anthropic Claude, and Google Gemini
+ */
+
+import type { AgentMessage, AgentTool, ToolCall } from '../agent-models';
+import { logError } from '../../../../shared/utils/logger';
+import {
+  DEFAULT_MODEL_ID,
+  getModelProvider,
+  type ModelProvider,
+} from '../model-catalog';
+export { DEFAULT_MODEL_ID } from '../model-catalog';
+export type { ModelProvider } from '../model-catalog';
+
+/** Truncate and redact LLM API error bodies to prevent API key / secret leakage. */
+function sanitizeLlmError(body: string, maxLen = 500): string {
+  return body
+    .slice(0, maxLen)
+    .replace(/sk-[A-Za-z0-9_-]{10,}/g, 'sk-***')
+    .replace(/key-[A-Za-z0-9_-]{10,}/g, 'key-***')
+    .replace(/Bearer\s+[A-Za-z0-9_-]+/gi, 'Bearer ***');
+}
+
+export interface ModelConfig {
+  provider: ModelProvider;
+  model: string;
+  apiKey: string;
+  maxTokens?: number;
+  temperature?: number;
+}
+
+export interface LLMResponse {
+  content: string;
+  toolCalls?: ToolCall[];
+  stopReason: 'stop' | 'tool_calls' | 'length';
+  usage: {
+    inputTokens: number;
+    outputTokens: number;
+  };
+}
+
+export interface LLMProvider {
+  chat(messages: AgentMessage[], tools?: AgentTool[], signal?: AbortSignal): Promise<LLMResponse>;
+}
+
+// ============================================================================
+// OpenAI Provider
+// ============================================================================
+
+interface OpenAIMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string | null;
+  tool_calls?: { id: string; type: 'function'; function: { name: string; arguments: string } }[];
+  tool_call_id?: string;
+}
+
+class OpenAIProvider implements LLMProvider {
+  constructor(private config: ModelConfig) {}
+
+  private convertTools(tools: AgentTool[]) {
+    return tools.map(tool => ({
+      type: 'function' as const,
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: 'object',
+          properties: tool.parameters.properties,
+          required: tool.parameters.required,
+        },
+      },
+    }));
+  }
+
+  private convertMessages(messages: AgentMessage[]): OpenAIMessage[] {
+    return messages.map(msg => {
+      if (msg.role === 'system' || msg.role === 'user') {
+        return { role: msg.role, content: msg.content };
+      }
+      if (msg.role === 'assistant') {
+        const openaiMsg: OpenAIMessage = { role: 'assistant', content: msg.content || null };
+        if (msg.tool_calls?.length) {
+          openaiMsg.tool_calls = msg.tool_calls.map(tc => ({
+            id: tc.id,
+            type: 'function' as const,
+            function: {
+              name: tc.name,
+              arguments: typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments || {}),
+            },
+          }));
+        }
+        return openaiMsg;
+      }
+      if (msg.role === 'tool') {
+        return { role: 'tool', content: msg.content, tool_call_id: msg.tool_call_id ?? '' };
+      }
+      return { role: msg.role as OpenAIMessage['role'], content: msg.content };
+    });
+  }
+
+  private isReasoningModel(): boolean {
+    const m = this.config.model;
+    return /^o[0-9]/.test(m) || m.includes('o1') || m.includes('o3') || m.includes('gpt-5');
+  }
+
+  async chat(messages: AgentMessage[], tools?: AgentTool[], signal?: AbortSignal): Promise<LLMResponse> {
+    const requestBody: Record<string, unknown> = {
+      model: this.config.model,
+      max_completion_tokens: this.config.maxTokens || 4096,
+      messages: this.convertMessages(messages),
+    };
+
+    // Reasoning models (o1, o3, etc.) only support temperature=1
+    if (!this.isReasoningModel()) {
+      requestBody.temperature = this.config.temperature ?? 1;
+    }
+
+    if (tools?.length) {
+      requestBody.tools = this.convertTools(tools);
+    }
+
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.config.apiKey}`,
+      },
+      body: JSON.stringify(requestBody),
+      signal,
+    });
+
+    if (!response.ok) {
+      const error = sanitizeLlmError(await response.text());
+      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+    }
+
+    const data = await response.json() as {
+      choices: { message: { content: string | null; tool_calls?: { id: string; function: { name: string; arguments: string } }[] }; finish_reason: string }[];
+      usage: { prompt_tokens: number; completion_tokens: number };
+    };
+
+    if (!data.choices || data.choices.length === 0) {
+      throw new Error('OpenAI API returned empty choices array');
+    }
+
+    const choice = data.choices[0];
+    const toolCalls: ToolCall[] = [];
+    if (choice.message.tool_calls) {
+      for (const tc of choice.message.tool_calls) {
+        try {
+          toolCalls.push({ id: tc.id, name: tc.function.name, arguments: JSON.parse(tc.function.arguments) });
+        } catch (e) {
+          logError('Failed to parse tool call', e, { module: 'services/agent/providers' });
+        }
+      }
+    }
+
+    return {
+      content: choice.message.content || '',
+      toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+      stopReason: choice.finish_reason as LLMResponse['stopReason'],
+      usage: { inputTokens: data.usage.prompt_tokens, outputTokens: data.usage.completion_tokens },
+    };
+  }
+}
+
+// ============================================================================
+// Anthropic Provider
+// ============================================================================
+
+interface AnthropicMessage {
+  role: 'user' | 'assistant';
+  content: string | { type: string; text?: string; tool_use_id?: string; content?: string; id?: string; name?: string; input?: unknown }[];
+}
+
+class AnthropicProvider implements LLMProvider {
+  constructor(private config: ModelConfig) {}
+
+  private convertTools(tools: AgentTool[]) {
+    return tools.map(tool => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: {
+        type: 'object',
+        properties: tool.parameters.properties,
+        required: tool.parameters.required,
+      },
+    }));
+  }
+
+  private convertMessages(messages: AgentMessage[]): { system: string; messages: AnthropicMessage[] } {
+    let systemPrompt = '';
+    const anthropicMessages: AnthropicMessage[] = [];
+
+    for (const msg of messages) {
+      if (msg.role === 'system') {
+        systemPrompt += (systemPrompt ? '\n\n' : '') + msg.content;
+        continue;
+      }
+
+      if (msg.role === 'user') {
+        anthropicMessages.push({ role: 'user', content: msg.content });
+      } else if (msg.role === 'assistant') {
+        if (msg.tool_calls?.length) {
+          const content: { type: string; id?: string; name?: string; input?: unknown; text?: string }[] = [];
+          if (msg.content) {
+            content.push({ type: 'text', text: msg.content });
+          }
+          for (const tc of msg.tool_calls) {
+            content.push({
+              type: 'tool_use',
+              id: tc.id,
+              name: tc.name,
+              input: tc.arguments,
+            });
+          }
+          anthropicMessages.push({ role: 'assistant', content });
+        } else {
+          anthropicMessages.push({ role: 'assistant', content: msg.content });
+        }
+      } else if (msg.role === 'tool') {
+        // Tool results need to be in a user message
+        const lastMsg = anthropicMessages[anthropicMessages.length - 1];
+        if (lastMsg?.role === 'user' && Array.isArray(lastMsg.content)) {
+          (lastMsg.content as { type: string; tool_use_id?: string; content?: string }[]).push({
+            type: 'tool_result',
+            tool_use_id: msg.tool_call_id ?? '',
+            content: msg.content,
+          });
+        } else {
+          anthropicMessages.push({
+            role: 'user',
+            content: [{ type: 'tool_result', tool_use_id: msg.tool_call_id ?? '', content: msg.content }],
+          });
+        }
+      }
+    }
+
+    return { system: systemPrompt, messages: anthropicMessages };
+  }
+
+  async chat(messages: AgentMessage[], tools?: AgentTool[], signal?: AbortSignal): Promise<LLMResponse> {
+    const { system, messages: anthropicMessages } = this.convertMessages(messages);
+
+    const requestBody: Record<string, unknown> = {
+      model: this.config.model,
+      max_tokens: this.config.maxTokens || 4096,
+      messages: anthropicMessages,
+    };
+
+    if (system) {
+      requestBody.system = system;
+    }
+
+    if (tools?.length) {
+      requestBody.tools = this.convertTools(tools);
+    }
+
+    const response = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': this.config.apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify(requestBody),
+      signal,
+    });
+
+    if (!response.ok) {
+      const error = sanitizeLlmError(await response.text());
+      throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+    }
+
+    const data = await response.json() as {
+      content: { type: string; text?: string; id?: string; name?: string; input?: unknown }[];
+      stop_reason: string;
+      usage: { input_tokens: number; output_tokens: number };
+    };
+
+    if (!data.content || !Array.isArray(data.content)) {
+      throw new Error('Anthropic API returned invalid content structure');
+    }
+
+    let textContent = '';
+    const toolCalls: ToolCall[] = [];
+
+    for (const block of data.content) {
+      if (block.type === 'text') {
+        textContent += block.text || '';
+      } else if (block.type === 'tool_use') {
+        toolCalls.push({
+          id: block.id ?? '',
+          name: block.name ?? '',
+          arguments: block.input as Record<string, unknown>,
+        });
+      }
+    }
+
+    return {
+      content: textContent,
+      toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+      stopReason: data.stop_reason === 'tool_use' ? 'tool_calls' : (data.stop_reason as LLMResponse['stopReason']),
+      usage: { inputTokens: data.usage.input_tokens, outputTokens: data.usage.output_tokens },
+    };
+  }
+}
+
+// ============================================================================
+// Google Gemini Provider
+// ============================================================================
+
+interface GeminiContent {
+  role: 'user' | 'model';
+  parts: { text?: string; functionCall?: { name: string; args: unknown }; functionResponse?: { name: string; response: unknown } }[];
+}
+
+class GoogleProvider implements LLMProvider {
+  constructor(private config: ModelConfig) {}
+
+  private convertTools(tools: AgentTool[]) {
+    return [{
+      functionDeclarations: tools.map(tool => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: 'OBJECT',
+          properties: Object.fromEntries(
+            Object.entries(tool.parameters.properties).map(([key, value]: [string, { type?: string; description?: string }]) => [
+              key,
+              { type: (value.type || 'string').toUpperCase(), description: value.description },
+            ])
+          ),
+          required: tool.parameters.required,
+        },
+      })),
+    }];
+  }
+
+  private convertMessages(messages: AgentMessage[]): { systemInstruction: string; contents: GeminiContent[] } {
+    let systemInstruction = '';
+    const contents: GeminiContent[] = [];
+
+    for (const msg of messages) {
+      if (msg.role === 'system') {
+        systemInstruction += (systemInstruction ? '\n\n' : '') + msg.content;
+        continue;
+      }
+
+      if (msg.role === 'user') {
+        contents.push({ role: 'user', parts: [{ text: msg.content }] });
+      } else if (msg.role === 'assistant') {
+        const parts: GeminiContent['parts'] = [];
+        if (msg.content) {
+          parts.push({ text: msg.content });
+        }
+        if (msg.tool_calls?.length) {
+          for (const tc of msg.tool_calls) {
+            parts.push({ functionCall: { name: tc.name, args: tc.arguments } });
+          }
+        }
+        if (parts.length) {
+          contents.push({ role: 'model', parts });
+        }
+      } else if (msg.role === 'tool') {
+        // Find the corresponding tool call name
+        const prevMsg = contents[contents.length - 1];
+        const functionCall = prevMsg?.parts.find(p => p.functionCall);
+        const name = functionCall?.functionCall?.name || 'unknown';
+
+        contents.push({
+          role: 'user',
+          parts: [{ functionResponse: { name, response: { result: msg.content } } }],
+        });
+      }
+    }
+
+    return { systemInstruction, contents };
+  }
+
+  async chat(messages: AgentMessage[], tools?: AgentTool[], signal?: AbortSignal): Promise<LLMResponse> {
+    const { systemInstruction, contents } = this.convertMessages(messages);
+
+    const requestBody: Record<string, unknown> = {
+      contents,
+      generationConfig: {
+        maxOutputTokens: this.config.maxTokens || 4096,
+        temperature: this.config.temperature ?? 1,
+      },
+    };
+
+    if (systemInstruction) {
+      requestBody.systemInstruction = { parts: [{ text: systemInstruction }] };
+    }
+
+    if (tools?.length) {
+      requestBody.tools = this.convertTools(tools);
+    }
+
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${this.config.model}:generateContent`;
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-goog-api-key': this.config.apiKey,
+      },
+      body: JSON.stringify(requestBody),
+      signal,
+    });
+
+    if (!response.ok) {
+      const error = sanitizeLlmError(await response.text());
+      throw new Error(`Google API error: ${response.status} - ${error}`);
+    }
+
+    const data = await response.json() as {
+      candidates: { content: { parts: { text?: string; functionCall?: { name: string; args: unknown } }[] }; finishReason: string }[];
+      usageMetadata: { promptTokenCount: number; candidatesTokenCount: number };
+    };
+
+    if (!data.candidates || data.candidates.length === 0) {
+      throw new Error('Google API returned empty candidates array');
+    }
+
+    const candidate = data.candidates[0];
+
+    if (!candidate.content || !candidate.content.parts) {
+      throw new Error('Google API returned invalid candidate content structure');
+    }
+    let textContent = '';
+    const toolCalls: ToolCall[] = [];
+
+    for (const part of candidate.content.parts) {
+      if (part.text) {
+        textContent += part.text;
+      } else if (part.functionCall) {
+        toolCalls.push({
+          id: `call_${crypto.randomUUID()}`,
+          name: part.functionCall.name,
+          arguments: part.functionCall.args as Record<string, unknown>,
+        });
+      }
+    }
+
+    const finishReason = candidate.finishReason === 'STOP' ? 'stop' :
+                         toolCalls.length > 0 ? 'tool_calls' : 'stop';
+
+    return {
+      content: textContent,
+      toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+      stopReason: finishReason as LLMResponse['stopReason'],
+      usage: {
+        inputTokens: data.usageMetadata?.promptTokenCount || 0,
+        outputTokens: data.usageMetadata?.candidatesTokenCount || 0,
+      },
+    };
+  }
+}
+
+// ============================================================================
+// Factory
+// ============================================================================
+
+export function createProvider(config: ModelConfig): LLMProvider {
+  switch (config.provider) {
+    case 'openai':
+      return new OpenAIProvider(config);
+    case 'anthropic':
+      return new AnthropicProvider(config);
+    case 'google':
+      return new GoogleProvider(config);
+    default:
+      throw new Error(`Unknown provider: ${config.provider}`);
+  }
+}
+
+/**
+ * Get provider from model ID
+ */
+export function getProviderFromModel(modelId: string): ModelProvider {
+  return getModelProvider(modelId);
+}

package/src/application/services/agent/remote-tool-executor.ts

@@ -0,0 +1,78 @@
+import type { ToolObserver } from '../memory-graph/graph-models';
+import type { ToolCall, ToolDefinition, ToolResult } from '../../tools/tool-definitions';
+import type { ToolExecutorLike } from '../../tools/executor';
+
+type RemoteToolCatalog = {
+  tools: ToolDefinition[];
+  mcpFailedServers: string[];
+};
+
+export interface RemoteToolExecutorIo {
+  getToolCatalog(input: { runId: string }): Promise<RemoteToolCatalog>;
+  executeTool(input: { runId: string; toolCall: ToolCall }): Promise<ToolResult>;
+  cleanupToolExecutor(input: { runId: string }): Promise<void>;
+}
+
+export class RemoteToolExecutor implements ToolExecutorLike {
+  private readonly io: RemoteToolExecutorIo;
+  private readonly runId: string;
+  private readonly tools: ToolDefinition[];
+  private readonly failedServers: string[];
+  private observer: ToolObserver | null = null;
+
+  private constructor(runId: string, catalog: RemoteToolCatalog, io: RemoteToolExecutorIo) {
+    this.io = io;
+    this.runId = runId;
+    this.tools = catalog.tools;
+    this.failedServers = catalog.mcpFailedServers;
+  }
+
+  static async create(runId: string, io: RemoteToolExecutorIo): Promise<RemoteToolExecutor> {
+    const catalog = await io.getToolCatalog({ runId });
+    return new RemoteToolExecutor(runId, {
+      tools: Array.isArray(catalog.tools) ? catalog.tools : [],
+      mcpFailedServers: Array.isArray(catalog.mcpFailedServers) ? catalog.mcpFailedServers : [],
+    }, io);
+  }
+
+  getAvailableTools(): ToolDefinition[] {
+    return this.tools;
+  }
+
+  get mcpFailedServers(): string[] {
+    return this.failedServers;
+  }
+
+  setObserver(observer: ToolObserver): void {
+    this.observer = observer;
+  }
+
+  async execute(toolCall: ToolCall): Promise<ToolResult> {
+    const startedAt = Date.now();
+    const result = await this.io.executeTool({
+      runId: this.runId,
+      toolCall,
+    });
+
+    if (this.observer) {
+      try {
+        this.observer.observe({
+          toolName: toolCall.name,
+          arguments: toolCall.arguments,
+          result: result.error ? '' : result.output,
+          error: result.error,
+          timestamp: startedAt,
+          duration: Date.now() - startedAt,
+        });
+      } catch {
+        // Best-effort observation.
+      }
+    }
+
+    return result;
+  }
+
+  async cleanup(): Promise<void> {
+    await this.io.cleanupToolExecutor({ runId: this.runId });
+  }
+}

package/src/application/services/agent/run-lifecycle.ts

@@ -0,0 +1,59 @@
+import type { RunStatus } from '../../../shared/types';
+import type { RunTerminalPayload } from '../run-notifier';
+import type { AgentEvent } from './agent-models';
+import { logError } from '../../../shared/utils/logger';
+
+// --- RunCancelledError (formerly services/agent/errors.ts) ---
+
+export class RunCancelledError extends Error {
+  constructor(message = 'Run cancelled') {
+    super(message);
+    this.name = 'RunCancelledError';
+  }
+}
+
+// --- Run reset policy (formerly services/agent/run-reset-policy.ts) ---
+
+export function shouldResetRunToQueuedOnContainerError(status: RunStatus | null | undefined): boolean {
+  return status === 'running';
+}
+
+export interface RunLifecycleDeps {
+  updateRunStatus: (status: RunStatus, output?: string, error?: string) => Promise<void>;
+  emitEvent: (type: AgentEvent['type'], data: Record<string, unknown>) => Promise<void>;
+  buildTerminalEventPayload: (
+    status: 'completed' | 'failed' | 'cancelled',
+    details?: Record<string, unknown>
+  ) => RunTerminalPayload;
+  autoCloseSession: (status: 'completed' | 'failed') => Promise<void>;
+  enqueuePostRunJobs: () => Promise<void>;
+  sanitizeErrorMessage: (error: string) => string;
+}
+
+export async function handleSuccessfulRunCompletion(deps: RunLifecycleDeps): Promise<void> {
+  await deps.enqueuePostRunJobs();
+  // Auto-close session if still open after successful completion
+  // Agent can still explicitly call container_commit/container_stop for control
+  await deps.autoCloseSession('completed');
+}
+
+export async function handleCancelledRun(deps: RunLifecycleDeps): Promise<void> {
+  await deps.updateRunStatus('cancelled', undefined, 'Run cancelled');
+  await deps.emitEvent('cancelled', deps.buildTerminalEventPayload('cancelled'));
+  await deps.autoCloseSession('failed');
+  await deps.enqueuePostRunJobs();
+}
+
+export async function handleFailedRun(deps: RunLifecycleDeps, error: unknown): Promise<void> {
+  const rawErrorMessage = String(error);
+  const errorMessage = deps.sanitizeErrorMessage(rawErrorMessage);
+  logError('Agent error', rawErrorMessage, { module: 'services/agent/run-lifecycle' }); // Full error for internal logs
+
+  await deps.updateRunStatus('failed', undefined, errorMessage);
+  await deps.emitEvent(
+    'error',
+    deps.buildTerminalEventPayload('failed', { error: errorMessage })
+  );
+  await deps.autoCloseSession('failed');
+  await deps.enqueuePostRunJobs();
+}

package/src/application/services/agent/runner-config.ts

@@ -0,0 +1,77 @@
+import type { AgentConfig } from './agent-models';
+import type { Env } from '../../../shared/types';
+import { BUILTIN_TOOLS } from '../../tools/builtin';
+import { SYSTEM_PROMPTS } from './prompt-builder';
+import { logWarn } from '../../../shared/utils/logger';
+import { parseIntValue, parseFloatValue } from 'takos-common/env-parse';
+import {
+  AGENT_ITERATION_TIMEOUT_MS,
+  AGENT_TOTAL_TIMEOUT_MS,
+  AGENT_TOOL_EXECUTION_TIMEOUT_MS,
+  AGENT_LANGGRAPH_TIMEOUT_MS,
+} from '../../../shared/config/timeouts';
+
+const DEFAULT_MAX_ITERATIONS = 10000;
+const DEFAULT_TEMPERATURE = 0.5;
+// Default timeouts — these apply when running in CF Workers (15-min Queue consumer limit).
+// When running inside a CF Container (executor), AGENT_TOTAL_TIMEOUT env var is set
+// to 86400000 (24h) and the 15-min cap is not enforced.
+export const DEFAULT_ITERATION_TIMEOUT = AGENT_ITERATION_TIMEOUT_MS;       // 2 min per LLM call
+export const DEFAULT_TOTAL_TIMEOUT = AGENT_TOTAL_TIMEOUT_MS;           // 15 min total (CF Workers Queue limit)
+const DEFAULT_TOOL_EXECUTION_TIMEOUT = AGENT_TOOL_EXECUTION_TIMEOUT_MS;  // 5 min per tool (e.g. build commands)
+const DEFAULT_LANGGRAPH_TIMEOUT = AGENT_LANGGRAPH_TIMEOUT_MS;       // 15 min for LangGraph (CF Workers)
+
+export function getTimeoutConfig(env?: Env): {
+  iterationTimeout: number;
+  totalTimeout: number;
+  toolExecutionTimeout: number;
+  langGraphTimeout: number;
+} {
+  const warn = (msg: string) => logWarn(msg, { module: 'services/agent/runner-config' });
+
+  const MIN_TIMEOUT = 1000;
+  // In CF Container mode, AGENT_TOTAL_TIMEOUT env var sets a higher limit (up to 24h).
+  // In CF Workers Queue mode, cap at 15 min (Queue consumer hard limit).
+  const MAX_TIMEOUT = env?.AGENT_TOTAL_TIMEOUT
+    ? Math.min(parseIntValue('AGENT_TOTAL_TIMEOUT', env.AGENT_TOTAL_TIMEOUT, 900000, { min: MIN_TIMEOUT, max: 86400000, warn }), 86400000)
+    : 900000; // default cap: 15 min (CF Workers Queue consumer limit)
+
+  const parseOpts = { min: MIN_TIMEOUT, max: MAX_TIMEOUT, warn };
+
+  return {
+    iterationTimeout: parseIntValue('AGENT_ITERATION_TIMEOUT', env?.AGENT_ITERATION_TIMEOUT, DEFAULT_ITERATION_TIMEOUT, parseOpts),
+    totalTimeout: parseIntValue('AGENT_TOTAL_TIMEOUT', env?.AGENT_TOTAL_TIMEOUT, DEFAULT_TOTAL_TIMEOUT, parseOpts),
+    toolExecutionTimeout: parseIntValue('TOOL_EXECUTION_TIMEOUT', env?.TOOL_EXECUTION_TIMEOUT, DEFAULT_TOOL_EXECUTION_TIMEOUT, parseOpts),
+    langGraphTimeout: parseIntValue('LANGGRAPH_TIMEOUT', env?.LANGGRAPH_TIMEOUT, DEFAULT_LANGGRAPH_TIMEOUT, parseOpts),
+  };
+}
+
+export function getAgentConfig(agentType: string, env?: Env): AgentConfig {
+  const warn = (msg: string) => logWarn(msg, { module: 'services/agent/runner-config' });
+
+  const systemPrompt = SYSTEM_PROMPTS[agentType] || SYSTEM_PROMPTS.default;
+
+  const tools = BUILTIN_TOOLS.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+  }));
+
+  const maxIterations = parseIntValue('MAX_AGENT_ITERATIONS', env?.MAX_AGENT_ITERATIONS, DEFAULT_MAX_ITERATIONS, { min: 1, warn });
+
+  const temperature = parseFloatValue('AGENT_TEMPERATURE', env?.AGENT_TEMPERATURE, DEFAULT_TEMPERATURE, { min: 0, max: 1, warn });
+
+  const rateLimitRaw = env?.AGENT_RATE_LIMIT
+    ? parseIntValue('AGENT_RATE_LIMIT', env.AGENT_RATE_LIMIT, 0, { min: 1, warn })
+    : undefined;
+  const rateLimit = rateLimitRaw && rateLimitRaw > 0 ? rateLimitRaw : undefined;
+
+  return {
+    type: agentType,
+    systemPrompt,
+    tools,
+    maxIterations,
+    temperature,
+    rateLimit,
+  };
+}