@contentful/experience-design-system-generation 2.34.5-dev-build-3e657f24.0 → 2.34.5-dev-build-b70b5f29.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-generation",
-  "version": "2.34.5-dev-build-3e657f24.0",
+  "version": "2.34.5-dev-build-b70b5f29.0",
   "description": "Agent-invocation and skill-prompt engine for the Contentful Experience Design System SDK",
   "license": "MIT",
   "type": "module",

package/dist/src/generate/adapters/local/local-agent-invoker.d.ts

@@ -0,0 +1,7 @@
+import type { AgentDebugEvent } from '../../model/invocation.js';
+import type { AgentInvoker } from '../../services/ports/agent-invoker.js';
+export interface CreateLocalCliAgentInvokerOptions {
+    /** Wire in a debug-event sink (e.g. the CLI's own debug logger). No-op by default. */
+    onDebugEvent?: AgentDebugEvent;
+}
+export declare function createLocalCliAgentInvoker(options?: CreateLocalCliAgentInvokerOptions): AgentInvoker;

package/dist/src/{agent-invoker.js → generate/adapters/local/local-agent-invoker.js}

@@ -1,5 +1,5 @@
-import { checkAgentAuth, runAgent } from './agent-runner.js';
-/** Default `AgentInvoker`: spawns the agent CLI binary as a local subprocess. */
+import { checkAgentAuth } from '../../services/agent-auth-service.js';
+import { runAgent } from './local-agent-process.js';
 export function createLocalCliAgentInvoker(options = {}) {
     const { onDebugEvent } = options;
     return {

package/dist/src/generate/adapters/local/local-agent-process.d.ts

@@ -0,0 +1,6 @@
+import type { AgentInvocationOptions, AgentDebugEvent, AgentRunResult } from '../../model/invocation.js';
+export interface LocalAgentRunOptions extends AgentInvocationOptions {
+    prompt: string;
+    onDebugEvent?: AgentDebugEvent;
+}
+export declare function runAgent(options: LocalAgentRunOptions): Promise<AgentRunResult>;

package/dist/src/generate/adapters/local/local-agent-process.js

@@ -0,0 +1,75 @@
+import { spawn } from 'node:child_process';
+import { buildArgs, resolveAgentEnvironment, resolveBinary } from '../../services/agent-configuration-service.js';
+export async function runAgent(options) {
+    const { agent, prompt, timeoutMs, model, onOutput, promptViaStdin, onDebugEvent } = options;
+    const bedrock = options.bedrock ?? process.env.EDS_BEDROCK === '1';
+    const binary = resolveBinary(agent);
+    const useStdin = !!promptViaStdin;
+    const args = buildArgs(agent, prompt, model, useStdin, bedrock);
+    const startedAt = Date.now();
+    onDebugEvent?.('run.start', {
+        agent,
+        binary,
+        model,
+        bedrock: !!bedrock,
+        timeoutMs,
+        promptLen: prompt.length,
+        promptHead: prompt.slice(0, 500),
+    });
+    return new Promise((resolve) => {
+        const bedrockEnv = resolveAgentEnvironment(agent, bedrock);
+        const child = spawn(binary, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            ...(bedrockEnv ? { env: { ...process.env, ...bedrockEnv } } : {}),
+        });
+        if (useStdin && child.stdin) {
+            child.stdin.on('error', () => { });
+            child.stdin.write(prompt, () => {
+                child.stdin?.end();
+            });
+        }
+        else {
+            child.stdin?.end();
+        }
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let spawnError;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+        }, timeoutMs);
+        child.stdout?.on('data', (chunk) => {
+            const text = chunk.toString();
+            stdout += text;
+            onOutput?.(text);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', (error) => {
+            spawnError = error;
+        });
+        child.on('close', (code, signal) => {
+            clearTimeout(timer);
+            const result = {
+                exitCode: spawnError || signal ? 1 : (code ?? 1),
+                stdout,
+                stderr: spawnError ? `${stderr}${spawnError.message}` : stderr,
+                timedOut,
+            };
+            onDebugEvent?.('run.end', {
+                agent,
+                model,
+                durationMs: Date.now() - startedAt,
+                exitCode: result.exitCode,
+                signal,
+                timedOut,
+                stdoutLen: stdout.length,
+                stderrLen: stderr.length,
+                stderrTail: stderr.slice(-1000),
+            });
+            resolve(result);
+        });
+    });
+}

package/dist/src/generate/controller/generate-endpoint.d.ts

@@ -0,0 +1,27 @@
+import type { GenerateEndpointRequest, GenerateEndpointResponse, GeneratePreviewRequest, GeneratePreviewResponse } from '../model/endpoint.js';
+import type { AgentRunResult } from '../model/invocation.js';
+import type { PromptOptions, Skill } from '../model/prompt.js';
+import type { ParsedMapTokenPropToolCalls, ParsedSelectToolCalls, ParsedTokenToolCalls, ParsedToolCalls } from '../model/protocol.js';
+import type { AgentInvoker } from '../services/ports/agent-invoker.js';
+export interface GeneratePromptService {
+    buildPrompt(options: PromptOptions): Promise<string>;
+}
+export interface GenerateProtocolParser {
+    parseComponents(stdout: string): ParsedToolCalls;
+    parseTokens(stdout: string): ParsedTokenToolCalls;
+    parseSelect(stdout: string): ParsedSelectToolCalls;
+    parseMapTokens(stdout: string): ParsedMapTokenPropToolCalls;
+}
+export interface GenerateEndpointDependencies {
+    invoker: AgentInvoker;
+    promptService?: GeneratePromptService;
+    protocolParser?: GenerateProtocolParser;
+    describeFailure?: (run: AgentRunResult) => string;
+}
+export interface GenerateEndpoint {
+    /** Builds the prompt, invokes the agent once, and parses the stage's protocol from its output. */
+    execute<Stage extends Skill>(request: GenerateEndpointRequest<Stage>): Promise<GenerateEndpointResponse<Stage>>;
+    /** Builds the prompt only, without invoking an agent. */
+    preview<Stage extends Skill>(request: GeneratePreviewRequest<Stage>): Promise<GeneratePreviewResponse<Stage>>;
+}
+export declare function createGenerateEndpoint(dependencies: GenerateEndpointDependencies): GenerateEndpoint;

package/dist/src/generate/controller/generate-endpoint.js

@@ -0,0 +1,52 @@
+import { GenerateRequestError } from '../model/errors.js';
+import { describeAgentFailure } from '../services/failure-diagnostics-service.js';
+import { buildPrompt } from '../services/prompt-service.js';
+import { parseMapTokenPropToolCallLines, parseSelectToolCallLines, parseTokenToolCallLines, parseToolCallLines, } from '../services/protocol-parser-service.js';
+const defaultPromptService = { buildPrompt };
+const defaultProtocolParser = {
+    parseComponents: parseToolCallLines,
+    parseTokens: parseTokenToolCallLines,
+    parseSelect: parseSelectToolCallLines,
+    parseMapTokens: parseMapTokenPropToolCallLines,
+};
+const STAGES_WITH_OPTIONAL_CALLS = new Set(['map-tokens']);
+export function createGenerateEndpoint(dependencies) {
+    const promptService = dependencies.promptService ?? defaultPromptService;
+    const protocolParser = dependencies.protocolParser ?? defaultProtocolParser;
+    const getFailure = dependencies.describeFailure ?? describeAgentFailure;
+    const stageParsers = {
+        components: protocolParser.parseComponents,
+        tokens: protocolParser.parseTokens,
+        select: protocolParser.parseSelect,
+        'map-tokens': protocolParser.parseMapTokens,
+    };
+    function requireStage(request) {
+        const stage = request.prompt.skill;
+        if (!Object.hasOwn(stageParsers, stage))
+            throw new GenerateRequestError('unknown-stage', stage);
+        return stage;
+    }
+    return {
+        async execute(request) {
+            const stage = requireStage(request);
+            const prompt = await promptService.buildPrompt(request.prompt);
+            const run = await dependencies.invoker.invoke({ ...request.invocation, prompt });
+            const { calls, warnings } = stageParsers[stage](run.stdout);
+            const failure = getRunFailure(run, stage, calls.length, getFailure);
+            return { stage, prompt, run, calls, warnings, ...(failure ? { failure } : {}) };
+        },
+        async preview(request) {
+            const stage = requireStage(request);
+            return { stage, prompt: await promptService.buildPrompt(request.prompt) };
+        },
+    };
+}
+function getRunFailure(run, stage, callCount, describeFailure) {
+    if (run.timedOut)
+        return 'agent timed out';
+    if (run.exitCode !== 0)
+        return describeFailure(run);
+    if (callCount === 0 && !STAGES_WITH_OPTIONAL_CALLS.has(stage))
+        return describeFailure(run);
+    return undefined;
+}

package/dist/src/generate/model/endpoint.d.ts

@@ -0,0 +1,30 @@
+import type { AgentInvocationOptions, AgentRunResult } from './invocation.js';
+import type { MapTokenPropCall, SelectToolCall, TokenToolCall, ToolCall } from './protocol.js';
+import type { PromptOptions, Skill } from './prompt.js';
+/** The tool calls each generation stage's agent is allowed to emit. */
+export interface StageToolCalls {
+    components: ToolCall;
+    tokens: TokenToolCall;
+    select: SelectToolCall;
+    'map-tokens': MapTokenPropCall;
+}
+/** A request for one generation attempt. The stage is the prompt's skill, so the two cannot disagree. */
+export interface GenerateEndpointRequest<Stage extends Skill = Skill> {
+    prompt: PromptOptions & {
+        skill: Stage;
+    };
+    invocation: AgentInvocationOptions;
+}
+export type GeneratePreviewRequest<Stage extends Skill = Skill> = Pick<GenerateEndpointRequest<Stage>, 'prompt'>;
+export interface GenerateEndpointResponse<Stage extends Skill = Skill> {
+    stage: Stage;
+    prompt: string;
+    run: AgentRunResult;
+    calls: Array<StageToolCalls[Stage]>;
+    warnings: string[];
+    failure?: string;
+}
+export interface GeneratePreviewResponse<Stage extends Skill = Skill> {
+    stage: Stage;
+    prompt: string;
+}

package/dist/src/generate/model/endpoint.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generate/model/errors.d.ts

@@ -0,0 +1,8 @@
+import type { Skill } from './prompt.js';
+export type GenerateRequestErrorReason = 'unknown-stage';
+/** A generation request the endpoint rejects before building a prompt or invoking an agent. */
+export declare class GenerateRequestError extends Error {
+    readonly reason: GenerateRequestErrorReason;
+    readonly stage: Skill | string;
+    constructor(reason: GenerateRequestErrorReason, stage: Skill | string);
+}

package/dist/src/generate/model/errors.js

@@ -0,0 +1,11 @@
+/** A generation request the endpoint rejects before building a prompt or invoking an agent. */
+export class GenerateRequestError extends Error {
+    reason;
+    stage;
+    constructor(reason, stage) {
+        super(`unsupported generation stage '${String(stage)}'`);
+        this.name = 'GenerateRequestError';
+        this.reason = reason;
+        this.stage = stage;
+    }
+}

package/dist/src/generate/model/invocation.d.ts

@@ -0,0 +1,18 @@
+import type { AgentName } from './agent.js';
+export interface AgentRunResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+}
+export type AgentDebugEvent = (name: string, payload?: Record<string, unknown>) => void;
+export type AgentAuthStatus = 'ok' | 'unauthenticated' | 'not-found';
+/** Transport-neutral options for one agent invocation attempt. */
+export interface AgentInvocationOptions {
+    agent: AgentName;
+    model?: string;
+    bedrock?: boolean;
+    timeoutMs: number;
+    onOutput?: (chunk: string) => void;
+    promptViaStdin?: boolean;
+}

package/dist/src/generate/model/invocation.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generate/model/progress.d.ts

@@ -0,0 +1,5 @@
+export interface GenerateProgressEvent {
+    done: number;
+    total: number;
+    name: string;
+}

package/dist/src/generate/model/progress.js

@@ -0,0 +1 @@
+export {};

package/dist/src/{prompt-builder.d.ts → generate/model/prompt.d.ts}

@@ -1,4 +1,4 @@
-import { type CDFComponentEntry } from '@contentful/experience-design-system-types';
+import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
 /** `components` — classify component props; `tokens` — classify design tokens; `select` — decide whether a component belongs in Contentful Experience Orchestration; `map-tokens` — suggest `$token.allowed` restrictions for design-category token props */
 export type Skill = 'components' | 'tokens' | 'select' | 'map-tokens';
 export type Mode = 'autonomous';
@@ -8,8 +8,8 @@ export type Mode = 'autonomous';
  * MAX_COMPONENT_SOURCE_CHARS) — this pipeline is agent-fs-free by design (see
  * generate-components.md's "you do not write any files"), so the caller must
  * read the file itself and inline the text here rather than handing the
- * agent a path and expecting it to open the file. `null` when the file
- * couldn't be read (moved/deleted since extraction) — callers fall back to
+ * agent a path and expecting it to open it. `null` when the file
+ * could not be read (moved/deleted since extraction) — callers fall back to
  * inferring from the prop name and $token.kind alone in that case.
  * `siblingFiles` carries the content of files the source file relatively
  * imports (e.g. a co-located `.styles.ts`) — token-resolution logic often
@@ -36,12 +36,6 @@ export interface ComponentSourceRef {
 }
 /** Plain-data shape of the CDF generated so far — component name -> component entry. */
 export type GeneratedCdf = Record<string, CDFComponentEntry>;
-/**
- * Render the warning banner shown when a custom skill prompt is active.
- * Always cites the bundled invariants that the override bypasses so the
- * operator cannot miss it.
- */
-export declare function formatCustomPromptBanner(skill: 'components' | 'select', path: string): string;
 export interface PromptOptions {
     skill: Skill;
     mode: Mode;
@@ -51,31 +45,24 @@ export interface PromptOptions {
     rawTokensFilename?: string;
     tokensInline?: string;
     tokenMapInline?: string;
+    /** Retained for source compatibility; prompt services do not read or write this path. */
     outDir: string;
     /** For components skill only: the single component's name (used in error messages). */
     componentName?: string;
-    /** For map-tokens skill: the CDF generated so far. Filtered internally to design-category token-typed props only. */
+    /** Generated CDF so far — used by map-tokens to show the agent what is already classified. */
     generatedCdf?: GeneratedCdf;
-    /** For map-tokens skill: the full DTCG token tree. Flattened internally to a path+`$type` index, with `$value` stripped. */
+    /** DTCG token tree — used by map-tokens to give the agent a candidate path index. */
     tokenTree?: Record<string, unknown>;
     /** Component source file references — consumption evidence for the components skill, explicit-restriction evidence (comments, allowlists) for map-tokens. */
     componentSourceRefs?: ComponentSourceRef[];
-    /**
-     * Feature 8: custom prompt path override. When set, this absolute or relative
-     * `.md` path is read in place of the bundled skill file. The bundled-prompt
-     * invariants (utility-wrapper rejection, description content rules, etc.) do
-     * NOT apply under an override — callers are responsible for showing the
-     * appropriate warning banner.
-     */
+    /** Feature 8: custom prompt path override. */
     skillPathOverride?: string;
     /** Inline prompt instructions, taking precedence over the bundled skill or path override. */
     skillContentOverride?: string;
-    /** JSON-serialized summary of existing space Components. Callers pre-project the shape per skill. */
+    /** JSON-serialized summary of existing space Components. */
     existingComponentsInline?: string;
-    /** JSON-serialized summary of existing space DesignTokens. Callers pre-project the shape per skill. */
+    /** JSON-serialized summary of existing space DesignTokens. */
     existingTokensInline?: string;
     /** JSON-serialized hard allowlist for generated slot allowed-components references. */
     componentAllowlistInline?: string;
 }
-export declare function buildPrompt(options: PromptOptions): Promise<string>;
-export declare function resolveSkillPath(skill: Skill): string;

package/dist/src/generate/model/prompt.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generate/model/protocol.d.ts

@@ -0,0 +1,91 @@
+export interface ClassifyPropCall {
+    tool: 'classify_prop';
+    prop: string;
+    cdf_type: string;
+    cdf_category: 'content' | 'design' | 'state';
+    values?: string[];
+    token_kind?: string;
+    required?: boolean;
+    description?: string;
+    default?: string | boolean;
+    /** Internal LLM rationale; not customer-facing. Persisted to raw_props.rationale. */
+    reason?: string;
+}
+export interface ExcludePropCall {
+    tool: 'exclude_prop';
+    prop: string;
+    reason: string;
+}
+export interface ClassifyComponentCall {
+    tool: 'classify_component';
+    description?: string;
+    /**
+     * Component-level rationale strings. Surfaced by the `I` ComponentRationalePanel.
+     * Each field is optional; missing fields leave existing DB values untouched
+     * (sparse update semantics in applyToolCalls).
+     */
+    rationale?: {
+        description?: string;
+        props?: string;
+        slots?: string;
+    };
+}
+export interface ClassifySlotCall {
+    tool: 'classify_slot';
+    slot: string;
+    required?: boolean;
+    allowed_components?: string[];
+    description?: string;
+    /** Per-slot rationale; persisted to raw_slots.rationale. */
+    rationale?: string;
+}
+export type ToolCall = ClassifyPropCall | ExcludePropCall | ClassifyComponentCall | ClassifySlotCall;
+export interface SelectComponentCall {
+    tool: 'select_component';
+    name: string;
+    reason?: string;
+    confidence?: number;
+}
+export interface RejectComponentCall {
+    tool: 'reject_component';
+    name: string;
+    reason?: string;
+    confidence?: number;
+}
+export type SelectToolCall = SelectComponentCall | RejectComponentCall;
+export interface ParsedSelectToolCalls {
+    calls: SelectToolCall[];
+    warnings: string[];
+}
+export interface SetTokenCall {
+    tool: 'set_token';
+    path: string;
+    type: string;
+    value: unknown;
+    description?: string;
+}
+export interface SetGroupCall {
+    tool: 'set_group';
+    path: string;
+    description?: string;
+}
+export type TokenToolCall = SetTokenCall | SetGroupCall;
+export interface ParsedTokenToolCalls {
+    calls: TokenToolCall[];
+    warnings: string[];
+}
+export interface ParsedToolCalls {
+    calls: ToolCall[];
+    warnings: string[];
+}
+export interface MapTokenPropCall {
+    tool: 'map_token_prop';
+    component: string;
+    prop: string;
+    /** Narrowed subset of tokens the prop may draw from. Required and non-empty. */
+    token_allowed: string[];
+}
+export interface ParsedMapTokenPropToolCalls {
+    calls: MapTokenPropCall[];
+    warnings: string[];
+}

package/dist/src/generate/model/protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generate/services/agent-auth-service.d.ts

@@ -0,0 +1,3 @@
+import type { AgentName } from '../model/agent.js';
+import type { AgentAuthStatus } from '../model/invocation.js';
+export declare function checkAgentAuth(agent: AgentName): Promise<AgentAuthStatus>;

package/dist/src/generate/services/agent-auth-service.js

@@ -0,0 +1,51 @@
+import { spawn } from 'node:child_process';
+import { resolveBinary } from './agent-configuration-service.js';
+export async function checkAgentAuth(agent) {
+    const binary = resolveBinary(agent);
+    const binaryExists = await new Promise((resolve) => {
+        if (binary.startsWith('/')) {
+            import('node:fs/promises').then((fs) => fs.access(binary).then(() => resolve(true), () => resolve(false)));
+            return;
+        }
+        const child = spawn(process.platform === 'win32' ? 'where' : 'which', [binary], { stdio: 'ignore' });
+        child.on('close', (code) => resolve(code === 0));
+    });
+    if (!binaryExists)
+        return 'not-found';
+    if (agent !== 'claude')
+        return 'ok';
+    return new Promise((resolve) => {
+        const child = spawn(binary, ['auth', 'status', '--json'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let done = false;
+        const timer = setTimeout(() => {
+            if (!done) {
+                done = true;
+                child.kill('SIGTERM');
+                resolve('unauthenticated');
+            }
+        }, 5000);
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.on('close', (code) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            if (code !== 0) {
+                resolve('unauthenticated');
+                return;
+            }
+            try {
+                const status = JSON.parse(stdout);
+                resolve(status.loggedIn ? 'ok' : 'unauthenticated');
+            }
+            catch {
+                resolve('unauthenticated');
+            }
+        });
+    });
+}

package/dist/src/generate/services/agent-configuration-service.d.ts

@@ -0,0 +1,12 @@
+import type { AgentName } from '../model/agent.js';
+export declare function resolveBinary(agent: AgentName): string;
+export declare function resolveAgentEnvironment(agent: AgentName, bedrock: boolean): Record<string, string> | undefined;
+export declare function agentSupportsBedrock(agent: AgentName): boolean;
+/**
+ * Resolve the model for an agent. Explicit flag/creds value wins, then a
+ * per-agent `EDS_AGENT_MODEL_<AGENT>` env override, otherwise the lightweight
+ * default for that agent. `bedrock` only affects the fallback default for
+ * agents whose model id changes shape under Bedrock.
+ */
+export declare function resolveAgentModel(agent: AgentName, explicit?: string, bedrock?: boolean): string | undefined;
+export declare function buildArgs(agent: AgentName, prompt: string, model?: string, promptViaStdin?: boolean, bedrock?: boolean): string[];

package/dist/src/generate/services/agent-configuration-service.js

@@ -0,0 +1,98 @@
+const AGENT_BINARIES = {
+    claude: 'claude',
+    codex: 'codex',
+    opencode: 'opencode',
+    cursor: 'cursor-agent',
+    copilot: 'copilot',
+};
+export function resolveBinary(agent) {
+    const envKey = `EDS_AGENT_BINARY_${agent.toUpperCase()}`;
+    const override = process.env[envKey];
+    if (override && override.trim())
+        return override.trim();
+    return AGENT_BINARIES[agent];
+}
+/** Per-agent env vars that switch model calls to AWS Bedrock. */
+const BEDROCK_ENV_BY_AGENT = {
+    claude: { CLAUDE_CODE_USE_BEDROCK: '1' },
+};
+export function resolveAgentEnvironment(agent, bedrock) {
+    return bedrock ? BEDROCK_ENV_BY_AGENT[agent] : undefined;
+}
+/**
+ * Agents with a working Bedrock routing mechanism, of any shape (env var,
+ * argv config override, or a provider-prefixed model string) — not just the
+ * env-var agents in BEDROCK_ENV_BY_AGENT. cursor is excluded: its own Bedrock
+ * support is currently broken for non-interactive/CI use.
+ */
+const BEDROCK_CAPABLE_AGENTS = new Set(['claude', 'codex', 'opencode']);
+export function agentSupportsBedrock(agent) {
+    return BEDROCK_CAPABLE_AGENTS.has(agent);
+}
+const DEFAULT_CODEX_BEDROCK_REGION = 'us-east-1';
+const DEFAULT_OPENCODE_MODEL = 'claude-haiku-4-5';
+/**
+ * Default models per agent — lightweight/fast picks to control cost when no
+ * explicit model is configured. cursor uses `gpt-mini` (verified alias from
+ * GetUsableModels; haiku is not available in cursor's model catalog).
+ *
+ * codex is deliberately absent: with no entry here it gets no `--model` at
+ * all, so the installed Codex CLI picks whatever its account supports. On
+ * Bedrock it still needs an explicit id, since the model id there carries an
+ * `openai.` prefix required by the Bedrock provider and absent from the
+ * direct api.openai.com id — see DEFAULT_CODEX_BEDROCK_MODEL.
+ */
+const DEFAULT_MODELS = {
+    claude: 'haiku',
+    opencode: DEFAULT_OPENCODE_MODEL,
+    cursor: 'gpt-mini',
+    copilot: 'Auto',
+};
+const DEFAULT_CODEX_BEDROCK_MODEL = 'openai.gpt-5.6-luna';
+/**
+ * Resolve the model for an agent. Explicit flag/creds value wins, then a
+ * per-agent `EDS_AGENT_MODEL_<AGENT>` env override, otherwise the lightweight
+ * default for that agent. `bedrock` only affects the fallback default for
+ * agents whose model id changes shape under Bedrock.
+ */
+export function resolveAgentModel(agent, explicit, bedrock = false) {
+    if (explicit && explicit.trim())
+        return explicit.trim();
+    const override = process.env[`EDS_AGENT_MODEL_${agent.toUpperCase()}`];
+    if (override && override.trim())
+        return override.trim();
+    if (bedrock && agent === 'codex')
+        return DEFAULT_CODEX_BEDROCK_MODEL;
+    if (bedrock && agent === 'opencode')
+        return withBedrockProviderPrefix(DEFAULT_OPENCODE_MODEL);
+    return DEFAULT_MODELS[agent];
+}
+function withBedrockProviderPrefix(model) {
+    return model.includes('/') ? model : `amazon-bedrock/${model}`;
+}
+function codexBedrockConfigArgs() {
+    const region = process.env.AWS_REGION?.trim() || process.env.AWS_DEFAULT_REGION?.trim() || DEFAULT_CODEX_BEDROCK_REGION;
+    return ['-c', 'model_provider=amazon-bedrock', '-c', `model_providers.amazon-bedrock.region=${region}`];
+}
+export function buildArgs(agent, prompt, model, promptViaStdin = false, bedrock = false) {
+    const resolvedModel = resolveAgentModel(agent, model, bedrock);
+    const modelArg = resolvedModel ? ['--model', resolvedModel] : [];
+    const promptArg = promptViaStdin ? [] : [prompt];
+    switch (agent) {
+        case 'claude':
+            return ['--print', ...modelArg, ...promptArg];
+        case 'codex': {
+            const bedrockArgs = bedrock ? codexBedrockConfigArgs() : [];
+            return ['exec', ...bedrockArgs, ...modelArg, '--dangerously-bypass-approvals-and-sandbox', ...promptArg];
+        }
+        case 'opencode':
+            return ['run', ...modelArg, ...promptArg];
+        case 'cursor':
+            return ['--print', ...modelArg, ...promptArg];
+        case 'copilot': {
+            const copilotModel = resolveAgentModel('copilot', model);
+            const copilotModelArg = !copilotModel || copilotModel === 'Auto' ? [] : ['--model', copilotModel];
+            return ['-p', ...promptArg, ...copilotModelArg, '--allow-all-tools'];
+        }
+    }
+}

package/dist/src/generate/services/failure-diagnostics-service.d.ts

@@ -0,0 +1,2 @@
+import type { AgentRunResult } from '../model/invocation.js';
+export declare function describeAgentFailure(result: AgentRunResult, maxDetail?: number): string;

package/dist/src/generate/services/failure-diagnostics-service.js

@@ -0,0 +1,5 @@
+export function describeAgentFailure(result, maxDetail = 800) {
+    const base = result.exitCode !== 0 ? `agent exited with code ${result.exitCode}` : 'agent produced no tool calls';
+    const detail = (result.stderr.trim() || result.stdout.trim()).slice(-maxDetail).trim();
+    return detail ? `${base} — ${detail}` : base;
+}

package/dist/src/generate/services/ports/agent-invoker.d.ts

@@ -0,0 +1,9 @@
+import type { AgentName } from '../../model/agent.js';
+import type { AgentAuthStatus, AgentInvocationOptions, AgentRunResult } from '../../model/invocation.js';
+export interface InvokeAgentOptions extends AgentInvocationOptions {
+    prompt: string;
+}
+export interface AgentInvoker {
+    invoke(options: InvokeAgentOptions): Promise<AgentRunResult>;
+    checkAuth(agent: AgentName): Promise<AgentAuthStatus>;
+}

package/dist/src/generate/services/ports/agent-invoker.js

@@ -0,0 +1 @@
+export {};

package/dist/src/generate/services/preambles/components.d.ts

@@ -0,0 +1 @@
+export declare function buildComponentsAutonomousPreamble(inputBlock: string): string;