@stigmer/runner 3.0.1

package/dist/activities/execute-deep-agent/prompt-builder.js

@@ -0,0 +1,200 @@
+/**
+ * System prompt construction for deep agent execution.
+ *
+ * Pure functions: no side effects, no I/O. Accepts pre-computed data
+ * (provision results, skill sections, file refs) and returns the
+ * assembled system prompt string.
+ */
+import { relative } from "node:path";
+import { SourceType } from "../../shared/workspace/types.js";
+const RESPONSE_RULES = `
+
+## Response rules
+
+- After using the read tool, NEVER reprint, echo, list, or summarize \
+file contents in your response. Tool results are already in your \
+context. Proceed directly to analysis or the task.
+- Do not begin responses with phrases like \
+"Below is the complete content", \
+"Here are the contents of the files", or similar. \
+The user did not ask you to display file contents.
+- Use backticks for file paths, function names, variable names, \
+and shell commands (e.g., \`src/main.py\`, \`handleRequest()\`, \
+\`npm install\`).
+- When referencing code, cite the file path — do not re-print \
+code blocks that the user can see in tool results.
+- Structure complex answers with headings and bullet points.
+- If you encounter something unexpected that changes the scope, \
+explain the issue and propose options before proceeding.
+`;
+const SUB_AGENT_RULES = `
+
+## Sub-agent delegation rules
+
+### Concurrency limit
+
+Do NOT spawn more than 3 sub-agents concurrently. If you need to \
+explore more than 3 areas, batch them: launch the first 3, wait for \
+results, then launch more if needed. The runtime enforces this limit — \
+excess sub-agents will be rejected.
+
+### When NOT to delegate
+
+- **Reading files.** Use the \`read\` tool yourself. You need raw file \
+contents in your own context to reason about them accurately.
+- **Single-step lookups.** Use \`grep\`, \`glob\`, \`search\`, or \`read\` \
+directly for simple searches across 1-2 files. Only delegate when \
+the task requires multi-step exploration.
+- **Data you will process yourself.** If you need the output in your \
+own context (e.g., to answer a question, write code, compare files), \
+do the work directly — do not delegate it.
+- **Small tasks (fewer than 3 steps).** The overhead of spawning a \
+sub-agent outweighs the benefit for trivial operations.
+
+### When TO delegate
+
+- Multi-step, independent tasks that produce a deliverable (analysis, \
+synthesis, generated content) you will incorporate into your response.
+- Parallel exploration of genuinely different areas of a codebase or \
+knowledge base when context isolation helps.
+- Tasks that benefit from a separate context window (e.g., long \
+document summarization that would crowd your own context).
+
+### Delegation best practices
+
+- When delegating, specify the **deliverable** you need — not \
+"read these files and give me the contents."
+- You MUST reference and synthesize sub-agent results in your \
+response. If you spawn a sub-agent, its output must visibly \
+influence your answer.
+- Each sub-agent consumes tokens and time. Prefer doing work \
+directly over delegating. Only delegate when context isolation \
+or parallelism genuinely helps the user.
+`;
+/**
+ * Assemble the full system prompt from base instructions and contextual
+ * sections. Pure function with no I/O.
+ */
+export function buildEnhancedSystemPrompt(input) {
+    let prompt = input.instructions;
+    const workspaceSection = buildWorkspacePromptSection(input.provisionResults, input.containerRoot);
+    if (workspaceSection) {
+        prompt += workspaceSection;
+    }
+    if (input.skillsPromptSection) {
+        prompt += input.skillsPromptSection;
+    }
+    if (input.workspaceFileRefs.length > 0) {
+        const refSection = buildReferencedFilesSection(input.workspaceFileRefs, input.workspaceRoot);
+        if (refSection) {
+            prompt += refSection;
+        }
+    }
+    if (input.injectedFiles.length > 0) {
+        prompt += buildInjectedFilesSection(input.injectedFiles);
+    }
+    prompt += RESPONSE_RULES;
+    prompt += SUB_AGENT_RULES;
+    return prompt;
+}
+function buildWorkspacePromptSection(provisionResults, containerRoot) {
+    if (provisionResults.length === 0)
+        return "";
+    if (provisionResults.length === 1) {
+        return buildSingleWorkspaceSection(provisionResults[0]);
+    }
+    return buildMultiWorkspaceSection(provisionResults, containerRoot);
+}
+function buildSingleWorkspaceSection(result) {
+    if (!result.workspaceDescription)
+        return "";
+    let section = "\n\n## Workspace\n\n" + result.workspaceDescription;
+    if (result.fileTree) {
+        section += "\n\n" + result.fileTree;
+    }
+    return section;
+}
+function buildMultiWorkspaceSection(results, containerRoot) {
+    const firstLabel = results[0].entryName || "entry-1";
+    let section = `\n\n## Workspace\n\n` +
+        `This session has ${results.length} workspace entries.\n\n` +
+        `**Path resolution**: All tools resolve paths relative to the ` +
+        `workspace root. Use entry-relative paths ` +
+        `(e.g., \`${firstLabel}/src/main.py\`). ` +
+        `Do not use absolute filesystem paths.\n`;
+    for (let idx = 0; idx < results.length; idx++) {
+        const result = results[idx];
+        const label = result.entryName || `entry-${idx + 1}`;
+        const relPath = workspaceRelativePath(result.rootDir, containerRoot);
+        section += `\n### ${label} (\`${relPath}\`)\n\n`;
+        section += formatEntryDescription(result);
+        if (result.fileTree) {
+            section += "\n\n" + result.fileTree;
+        }
+    }
+    return section;
+}
+function workspaceRelativePath(rootDir, containerRoot) {
+    if (!containerRoot)
+        return rootDir;
+    try {
+        const rel = relative(containerRoot, rootDir);
+        if (rel.startsWith(".."))
+            return rootDir;
+        return rel;
+    }
+    catch {
+        return rootDir;
+    }
+}
+function formatEntryDescription(result) {
+    const name = result.entryName || "this entry";
+    if (result.sourceType === SourceType.LOCAL_PATH) {
+        return (`Workspace entry **${name}** is the user's project directory ` +
+            `at \`${result.rootDir}\`.\n` +
+            "You are operating directly on the user's files — changes are " +
+            "immediate and persistent. Use git to track and verify your changes.");
+    }
+    if (result.sourceType === SourceType.GIT_REPO && result.gitMetadata) {
+        const meta = result.gitMetadata;
+        const shortSha = meta.baseCommit.length >= 7
+            ? meta.baseCommit.slice(0, 7)
+            : meta.baseCommit;
+        return (`Workspace entry **${name}** was initialized from ` +
+            `${meta.repoUrl} (branch: ${meta.branch}, commit: ${shortSha}).\n` +
+            "Changes you make will be captured as artifacts when execution completes.");
+    }
+    if (result.sourceType === SourceType.EMPTY) {
+        return (`Workspace entry **${name}** is an empty workspace.\n` +
+            "Create files and directories as needed for your task.");
+    }
+    return result.workspaceDescription;
+}
+function buildReferencedFilesSection(workspaceFileRefs, _workspaceRoot) {
+    if (workspaceFileRefs.length === 0)
+        return "";
+    let section = "\n\n## Referenced Files\n\n" +
+        "The user has highlighted the following workspace paths for your " +
+        "attention. Use `read` to access file contents.\n\n";
+    for (const refPath of workspaceFileRefs) {
+        section += `- \`${refPath}\`\n`;
+    }
+    return section;
+}
+function buildInjectedFilesSection(files) {
+    let section = "\n\n## Input Files\n\n";
+    section +=
+        "The following files have been provided as read-only reference " +
+            "material for your task. They live under `.stigmer/inputs/` and " +
+            "are NOT part of the project source tree.\n\n" +
+            "Read them using the `read` tool when you need their contents. " +
+            "Do NOT echo, reprint, or summarize file contents in your response " +
+            "-- they are reference material, not output. " +
+            "Do NOT modify or delete these files.\n\n";
+    for (const f of files) {
+        const sizeInfo = f.size != null ? ` (${f.size} bytes)` : "";
+        section += `- \`${f.path}\`${sizeInfo}\n`;
+    }
+    return section;
+}
+//# sourceMappingURL=prompt-builder.js.map

package/dist/activities/execute-deep-agent/prompt-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-builder.js","sourceRoot":"","sources":["../../../src/activities/execute-deep-agent/prompt-builder.ts"],"names":[],"mappings":"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"}

package/dist/activities/execute-deep-agent/setup.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Execution setup pipeline for the deep agent activity.
+ *
+ * Hydrates the execution from the database, resolves the full resource
+ * chain (session -> agentInstance -> agent), provisions workspace, loads
+ * MCP servers / environment, creates the LangGraph agent graph with the
+ * full middleware stack, and returns a SetupResult containing everything
+ * the streaming phase needs.
+ */
+type AgentGraph = any;
+import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import type { Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
+import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import type { Config } from "../../config.js";
+import type { StigmerClient } from "../../client/stigmer-client.js";
+import { type McpConnectionResult } from "../../shared/mcp-manager.js";
+import type { WorkspaceBackend, ProvisionResult } from "../../shared/workspace/types.js";
+import type { GracefulStopMiddleware } from "../../middleware/index.js";
+import { type ArtifactStorage } from "../../shared/artifact-storage.js";
+import { type MergedToolPolicy } from "../../shared/approval-policy.js";
+export interface SetupResult {
+    readonly agentGraph: AgentGraph;
+    readonly langgraphConfig: Record<string, unknown>;
+    readonly langgraphInput: Record<string, unknown>;
+    readonly execution: AgentExecution;
+    readonly agent: Agent;
+    readonly session: Session;
+    readonly workspaceBackend: WorkspaceBackend;
+    readonly mcpConnection: McpConnectionResult | null;
+    readonly mergedEnvVars: Record<string, string>;
+    readonly secretKeys: ReadonlySet<string>;
+    readonly modelName: string;
+    readonly gracefulStop: GracefulStopMiddleware;
+    readonly artifactStorage: ArtifactStorage;
+    readonly provisionResults: readonly ProvisionResult[];
+    readonly approvalPolicies: ReadonlyMap<string, MergedToolPolicy>;
+    readonly toolServerMap: ReadonlyMap<string, string>;
+    readonly autoApproveAll: boolean;
+    readonly hasStructuredOutput: boolean;
+    readonly streamVersion: "v2" | "v3";
+}
+export interface SetupDependencies {
+    config: Config;
+    client: StigmerClient;
+    executionId: string;
+    threadId: string;
+}
+/**
+ * Execute all setup phases and return resources for the streaming phase.
+ *
+ * On failure, partial resources (MCP connections, workspace backend) are
+ * cleaned up internally before re-throwing.
+ */
+export declare function performSetup(deps: SetupDependencies): Promise<SetupResult>;
+export {};

package/dist/activities/execute-deep-agent/setup.js

@@ -0,0 +1,411 @@
+/**
+ * Execution setup pipeline for the deep agent activity.
+ *
+ * Hydrates the execution from the database, resolves the full resource
+ * chain (session -> agentInstance -> agent), provisions workspace, loads
+ * MCP servers / environment, creates the LangGraph agent graph with the
+ * full middleware stack, and returns a SetupResult containing everything
+ * the streaming phase needs.
+ */
+import { createDeepAgent, FilesystemBackend } from "deepagents";
+import { InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { ChatAnthropic } from "@langchain/anthropic";
+import { ChatOpenAI } from "@langchain/openai";
+import { createCheckpointer } from "../../shared/checkpointer/factory.js";
+import { connectMcpServers } from "../../shared/mcp-manager.js";
+import { resolveMcpServers } from "../../shared/mcp-resolver.js";
+import { backfillMcpServersIfNeeded } from "../../shared/connect-backfill.js";
+import { WorkspaceProvisioner } from "../../shared/workspace/provisioner.js";
+import { LocalWorkspaceBackend } from "../../shared/workspace/local-backend.js";
+import { ensurePlatformDir } from "../../shared/workspace/platform-dir.js";
+import { reportSetupProgress } from "../../shared/status.js";
+import { resolveEnvironment } from "./environment.js";
+import { buildEnhancedSystemPrompt } from "./prompt-builder.js";
+import { buildMiddlewareStack, createThinkTool } from "../../middleware/index.js";
+import { getModelPricing, ensureLoaded as ensurePricingLoaded } from "../../shared/model-pricing.js";
+import { getDefaultModel } from "../../shared/model-registry.js";
+import { loadArtifactStorageConfig, createArtifactStorage, } from "../../shared/artifact-storage.js";
+import { mergeApprovalPolicies, hasApproveAllDecision, } from "../../shared/approval-policy.js";
+import { inferProvider, stripProviderPrefix, resolveProxyBaseUrl, buildProxyHeaders, } from "../../shared/llm-proxy.js";
+import { mergeSkillRefs, fetchSkillsByRefs, writeSkills, generatePromptSection, generateAlsoAvailableSection, fetchSkillArtifacts, } from "../../shared/skill-writer.js";
+import { filterSkills, SKILL_COUNT_THRESHOLD } from "../../shared/skill-relevance.js";
+import { injectAttachments } from "./attachment-injector.js";
+import { transformAndCompileSubagents } from "./subagent-transformer.js";
+/**
+ * Execute all setup phases and return resources for the streaming phase.
+ *
+ * On failure, partial resources (MCP connections, workspace backend) are
+ * cleaned up internally before re-throwing.
+ */
+export async function performSetup(deps) {
+    const { config, client, executionId, threadId } = deps;
+    let mcpConnection = null;
+    try {
+        // Step 1: Hydrate execution
+        await reportSetupProgress(client, executionId, "Fetching execution…");
+        const execution = await client.getExecution(executionId);
+        console.log(`[setup] Execution fetched: agent_id=${execution.spec?.agentId}`);
+        // Step 2: Resolve chain — execution → session → agentInstance → agent
+        await reportSetupProgress(client, executionId, "Resolving agent…");
+        const sessionId = execution.spec.sessionId;
+        if (!sessionId) {
+            throw new Error(`Session ID is required for execution ${executionId}. ` +
+                "Execution must have a valid session_id.");
+        }
+        const session = await client.getSession(sessionId);
+        const agentInstance = await client.getAgentInstance(session.spec.agentInstanceId);
+        const agent = await client.getAgent(agentInstance.spec.agentId);
+        const instructions = agent.spec.instructions || "You are a helpful AI assistant.";
+        console.log(`[setup] Chain resolved: session=${sessionId}, ` +
+            `agent=${agent.metadata.name}`);
+        // Step 3: Resolve model
+        const modelName = execution.spec.executionConfig?.modelName
+            || await getDefaultModel();
+        // Step 4: Create checkpointer
+        const checkpointer = await createCheckpointer({
+            type: config.checkpointerType,
+            proxyEndpoint: config.checkpointerProxyEndpoint ?? undefined,
+            authToken: config.stigmerToken ?? undefined,
+        });
+        // Step 5: Resolve environment
+        await reportSetupProgress(client, executionId, "Resolving environment…");
+        const envResult = await resolveEnvironment(client, executionId);
+        // Step 6: Create artifact storage
+        const artifactStorageConfig = loadArtifactStorageConfig(config);
+        const artifactStorage = createArtifactStorage(artifactStorageConfig);
+        // Step 7: Provision workspace
+        await reportSetupProgress(client, executionId, "Initializing workspace…");
+        const { workspaceBackend, provisionResults } = await provisionWorkspace(config, session, envResult.mergedEnvVars, sessionId);
+        // Step 7: Resolve and connect MCP servers
+        const mcpServerUsages = [
+            ...(agent.spec.mcpServerUsages || []),
+            ...(session.spec.mcpServerUsages || []),
+        ];
+        let resolvedMcpServers = null;
+        if (mcpServerUsages.length > 0) {
+            await reportSetupProgress(client, executionId, "Connecting tools…");
+            resolvedMcpServers = await resolveMcpServers(client, mcpServerUsages, envResult.mergedEnvVars);
+            const sessionOrg = session.metadata?.org ?? "";
+            const backfilledServers = await backfillMcpServersIfNeeded(client, resolvedMcpServers.resolvedServers, mcpServerUsages, envResult.mergedEnvVars, sessionOrg, undefined, envResult.secretKeys);
+            resolvedMcpServers = { resolvedServers: backfilledServers };
+            mcpConnection = await connectMcpServers(resolvedMcpServers.resolvedServers, { isCloudMode: config.cloudModeEnabled });
+        }
+        // Step 7b: Resolve and write skills
+        const skillRefs = mergeSkillRefs(agent.spec.skillRefs || [], session.spec.skillRefs || []);
+        let skillsPromptSection = "";
+        if (skillRefs.length > 0) {
+            await reportSetupProgress(client, executionId, "Loading skills…");
+            const skills = await fetchSkillsByRefs(client, skillRefs);
+            if (skills.length > 0) {
+                const artifacts = await fetchSkillArtifacts(client, skills);
+                const { paths: skillPaths } = await writeSkills(skills, workspaceBackend, artifacts);
+                const userMessage = execution.spec.message || "";
+                const skillNames = skills.map(s => s.spec?.name || s.metadata?.slug || "unknown");
+                const skillDescriptions = skills.map(s => s.spec?.description || "");
+                if (skills.length >= SKILL_COUNT_THRESHOLD) {
+                    const filterResult = filterSkills(userMessage, skillNames, skillDescriptions);
+                    if (filterResult.excludedNames.length > 0) {
+                        const includedSkills = filterResult.includedIndices.map(i => skills[i]);
+                        console.log(`[setup] Skill relevance filter: ${includedSkills.length} included, ` +
+                            `${filterResult.excludedNames.length} excluded: ${filterResult.excludedNames.join(", ")}`);
+                        skillsPromptSection =
+                            generatePromptSection(includedSkills, skillPaths) +
+                                generateAlsoAvailableSection(filterResult.excludedNames);
+                    }
+                    else {
+                        skillsPromptSection = generatePromptSection(skills, skillPaths);
+                    }
+                }
+                else {
+                    skillsPromptSection = generatePromptSection(skills, skillPaths);
+                }
+                console.log(`[setup] Skills loaded: ${skills.length} total, prompt section ${skillsPromptSection.length} chars`);
+            }
+        }
+        // Step 7c: Inject attachments
+        const attachments = execution.spec.attachments || [];
+        const injectedFiles = await injectAttachments({
+            backend: workspaceBackend,
+            attachments,
+            storage: artifactStorage,
+            isLocalMode: config.mode === "local",
+        });
+        // Step 8: Build enhanced system prompt
+        const systemPrompt = buildEnhancedSystemPrompt({
+            instructions,
+            provisionResults,
+            containerRoot: workspaceBackend.rootDir,
+            skillsPromptSection,
+            workspaceFileRefs: execution.spec.workspaceFileRefs || [],
+            workspaceRoot: workspaceBackend.rootDir,
+            injectedFiles,
+        });
+        // Step 9: Construct the LLM model
+        const model = constructModel(modelName, config, executionId);
+        // Step 10: Build middleware stack
+        await ensurePricingLoaded();
+        const pricing = getModelPricing(modelName);
+        const execConfig = execution.spec.executionConfig;
+        const toolServerMap = new Map();
+        if (mcpConnection) {
+            for (const [serverName, serverTools] of Object.entries(mcpConnection.serverToolMap)) {
+                for (const t of serverTools) {
+                    toolServerMap.set(t.name, serverName);
+                }
+            }
+        }
+        // Step 10b: Resolve approval policies
+        //
+        // Effective auto-approve is true when EITHER the execution was pre-armed via
+        // spec.auto_approve_all (CLI --auto-approve, API, CI/CD) OR a user chose
+        // APPROVE_ALL ("approve and don't ask again") at some gate earlier in this
+        // run. In both cases the gate is disabled for the rest of the execution, and
+        // the value propagates to mergeApprovalPolicies and (below) to sub-agents so
+        // they inherit it. See the ApprovalAction doc in enum.proto.
+        const autoApproveAll = (execution.spec.autoApproveAll ?? false) || hasApproveAllDecision(execution);
+        const agentOverrides = agent.spec.mcpServerUsages?.flatMap(u => u.toolApprovalOverrides ?? []) ?? [];
+        const approvalPolicies = mergeApprovalPolicies(resolvedMcpServers?.resolvedServers ?? [], agentOverrides, autoApproveAll);
+        const maxCostUsd = execConfig?.maxCostUsd ?? 0;
+        const { middleware, gracefulStop, costCap: costCapMiddleware } = buildMiddlewareStack({
+            loopDetection: {
+                historySize: 20,
+                consecutiveThreshold: 7,
+                totalThreshold: 20,
+            },
+            executionBudget: {
+                recursionLimit: execConfig?.maxToolRounds
+                    ? execConfig.maxToolRounds * 6
+                    : 6000,
+                warningPct: 80,
+            },
+            toolTruncation: {
+                maxChars: execConfig?.maxToolResultChars || 30_000,
+            },
+            costCap: maxCostUsd > 0 ? {
+                maxCostUsd,
+                inputPricePerMillion: pricing.inputPricePerMillion,
+                outputPricePerMillion: pricing.outputPricePerMillion,
+                cacheReadPricePerMillion: pricing.cacheReadPricePerMillion,
+                warningPct: 80,
+            } : null,
+            otelSpans: { toolServerMap },
+            approvalGate: !autoApproveAll ? {
+                policies: approvalPolicies,
+                autoApproveAll,
+                toolServerMap,
+            } : null,
+        });
+        // Step 11: Build tools list (MCP tools + think tool)
+        const tools = [
+            ...(mcpConnection?.tools ?? []),
+            createThinkTool(),
+        ];
+        // Step 11b: Transform and compile subagents
+        const subAgentProtos = agent.spec.subAgents || [];
+        let compiledSubagents;
+        if (subAgentProtos.length > 0 || workspaceBackend.rootDir) {
+            await reportSetupProgress(client, executionId, "Configuring sub-agents…");
+            const parentMcpServerToolMap = new Map();
+            if (mcpConnection) {
+                for (const [serverName, serverTools] of Object.entries(mcpConnection.serverToolMap)) {
+                    parentMcpServerToolMap.set(serverName, serverTools);
+                }
+            }
+            compiledSubagents = await transformAndCompileSubagents({
+                subAgents: subAgentProtos,
+                parentMcpTools: mcpConnection?.tools ?? [],
+                parentMcpServerToolMap,
+                parentMcpUsages: mcpServerUsages,
+                skillClient: client,
+                workspaceBackend,
+                approvalPolicies,
+                autoApproveAll,
+                parentModelName: modelName,
+                parentHasNativeThinking: _modelHasNativeThinking(modelName),
+                costCap: costCapMiddleware ?? undefined,
+                modelFactory: (m) => constructModel(m, config, executionId),
+            });
+        }
+        // Step 12: Create the agent graph with middleware
+        await reportSetupProgress(client, executionId, "Creating agent…");
+        const outputSchema = execution.spec.executionConfig?.structuredOutputSchema;
+        let responseFormat;
+        if (outputSchema) {
+            responseFormat = jsonSchemaToZod(outputSchema);
+        }
+        // Plan mode is read-only. Deny every filesystem write operation at the tool
+        // level so write_file/edit_file/etc. cannot mutate the workspace — enforcing
+        // the InteractionMode.PLAN contract by construction, not by prompt. Rules are
+        // first-match-wins with a permissive default, so a single deny-all-writes
+        // rule is sufficient. (The Cursor harness enforces plan mode via its prompt
+        // prefix; the native harness enforces it here.)
+        const isPlanMode = execConfig?.interactionMode === InteractionMode.PLAN;
+        const planModePermissions = [
+            { operations: ["write"], paths: ["/**"], mode: "deny" },
+        ];
+        const agentGraph = await createDeepAgent({
+            model,
+            checkpointer: checkpointer,
+            backend: new FilesystemBackend({ rootDir: workspaceBackend.rootDir }),
+            systemPrompt,
+            tools,
+            middleware: middleware,
+            subagents: compiledSubagents ?? undefined,
+            ...(responseFormat ? { responseFormat } : {}),
+            ...(isPlanMode ? { permissions: planModePermissions } : {}),
+        });
+        // Step 11: Prepare invocation input and config
+        let userMessage = execution.spec.message;
+        if (outputSchema) {
+            userMessage += `\n\n---\nIMPORTANT: When your analysis is complete, provide your findings as structured output matching the required schema. The system will capture your structured response automatically.`;
+        }
+        const langgraphInput = {
+            messages: [{ role: "user", content: userMessage }],
+        };
+        const langgraphConfig = {
+            configurable: { thread_id: threadId },
+        };
+        const streamVersion = process.env.LANGGRAPH_STREAM_EVENTS_VERSION === "v2" ? "v2" : "v3";
+        console.log(`[setup] Complete: model=${modelName}, ` +
+            `tools=${tools.length}, middleware=${middleware.length}, ` +
+            `thread_id=${threadId}, streamVersion=${streamVersion}`);
+        return {
+            agentGraph,
+            langgraphConfig,
+            langgraphInput,
+            execution,
+            agent,
+            session,
+            workspaceBackend,
+            mcpConnection,
+            mergedEnvVars: envResult.mergedEnvVars,
+            secretKeys: envResult.secretKeys,
+            modelName,
+            gracefulStop,
+            artifactStorage,
+            provisionResults,
+            approvalPolicies,
+            toolServerMap,
+            autoApproveAll,
+            hasStructuredOutput: !!outputSchema,
+            streamVersion,
+        };
+    }
+    catch (err) {
+        if (mcpConnection) {
+            try {
+                await mcpConnection.client.close();
+            }
+            catch { /* swallow */ }
+        }
+        throw err;
+    }
+}
+/**
+ * Construct the appropriate chat model for the given model name.
+ *
+ * Provider inference uses name prefix heuristics (claude → Anthropic,
+ * gpt/o1/o3/o4 → OpenAI). In proxy mode, requests route through the
+ * stigmer-cloud LlmProxyController at provider-specific paths.
+ */
+function constructModel(modelName, config, executionId) {
+    const provider = inferProvider(modelName);
+    const apiModelId = stripProviderPrefix(modelName);
+    const baseUrl = config.proxyEndpoint
+        ? resolveProxyBaseUrl(config.proxyEndpoint, provider)
+        : undefined;
+    const headers = config.proxyEndpoint && config.stigmerToken
+        ? buildProxyHeaders(config.stigmerToken, { executionId })
+        : undefined;
+    switch (provider) {
+        case "anthropic":
+            return buildAnthropicModel(apiModelId, baseUrl, headers, config);
+        case "openai":
+            return buildOpenAIModel(apiModelId, baseUrl, headers, config);
+    }
+}
+function buildAnthropicModel(model, baseUrl, headers, config) {
+    const apiKey = config.proxyEndpoint
+        ? (config.stigmerToken ?? "proxy-managed")
+        : (process.env.ANTHROPIC_API_KEY ?? "");
+    const requestTimeoutMs = parseInt(process.env.STIGMER_LLM_REQUEST_TIMEOUT_MS ?? "0") || undefined;
+    return new ChatAnthropic({
+        model,
+        apiKey,
+        temperature: 0,
+        ...(requestTimeoutMs ? { maxRetries: 0, timeout: requestTimeoutMs } : {}),
+        ...(baseUrl || headers
+            ? {
+                clientOptions: {
+                    ...(baseUrl ? { baseURL: baseUrl } : {}),
+                    ...(headers ? { defaultHeaders: headers } : {}),
+                },
+            }
+            : {}),
+    });
+}
+function buildOpenAIModel(model, baseUrl, headers, config) {
+    const apiKey = config.proxyEndpoint
+        ? (config.stigmerToken ?? "proxy-managed")
+        : (process.env.OPENAI_API_KEY ?? "");
+    const requestTimeoutMs = parseInt(process.env.STIGMER_LLM_REQUEST_TIMEOUT_MS ?? "0") || undefined;
+    return new ChatOpenAI({
+        model,
+        apiKey,
+        temperature: 0,
+        ...(requestTimeoutMs ? { maxRetries: 0, timeout: requestTimeoutMs } : {}),
+        ...(baseUrl || headers
+            ? {
+                configuration: {
+                    ...(baseUrl ? { baseURL: baseUrl } : {}),
+                    ...(headers ? { defaultHeaders: headers } : {}),
+                },
+            }
+            : {}),
+    });
+}
+/**
+ * Provision workspace from session workspace entries.
+ */
+async function provisionWorkspace(config, session, mergedEnvVars, sessionId) {
+    const platformDir = await ensurePlatformDir(sessionId);
+    const workspaceBackend = new LocalWorkspaceBackend(config.workspaceRootDir, platformDir);
+    const workspaceEntries = session.spec.workspaceEntries || [];
+    if (workspaceEntries.length === 0) {
+        return { workspaceBackend, provisionResults: [] };
+    }
+    const provisioner = new WorkspaceProvisioner();
+    const provisionResults = await provisioner.provisionAll(workspaceEntries.map(entry => ({
+        name: entry.name,
+        source: entry.source,
+    })), workspaceBackend, mergedEnvVars, config.mode === "local", config.mode !== "local");
+    // If single entry changed root dir, create a new backend with the same platformDir
+    if (provisionResults.length === 1 &&
+        provisionResults[0].rootDir !== workspaceBackend.rootDir) {
+        return {
+            workspaceBackend: new LocalWorkspaceBackend(provisionResults[0].rootDir, platformDir),
+            provisionResults,
+        };
+    }
+    return { workspaceBackend, provisionResults };
+}
+// Shared JSON Schema → Zod converter (consolidated from 3 duplicate copies).
+import { jsonSchemaToZod } from "../../shared/json-schema-to-zod.js";
+/**
+ * Heuristic check for native extended thinking support.
+ * Models with thinking support don't need the explicit think tool.
+ */
+function _modelHasNativeThinking(modelId) {
+    const lower = modelId.toLowerCase();
+    if (lower.includes("haiku"))
+        return false;
+    if (lower.includes("gpt-4o-mini"))
+        return false;
+    if (lower.includes("claude") && (lower.includes("sonnet") || lower.includes("opus")))
+        return true;
+    if (lower.includes("o1") || lower.includes("o3") || lower.includes("o4")) {
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=setup.js.map