@contentful/experience-design-system-generation 2.36.2-dev-build-a6f80ae6.0 → 2.36.2-dev-build-d9a75f6e.0

package/dist/package.json

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

package/dist/src/agent-names.d.ts

@@ -1,4 +1,5 @@
 export declare const AGENT_NAMES: readonly ["claude", "codex", "opencode", "cursor", "copilot"];
 export type AgentName = (typeof AGENT_NAMES)[number];
 export declare const DEFAULT_AGENT_NAME: AgentName;
+export declare const AGENT_BINARIES: Record<AgentName, string>;
 export declare function isAgentName(value: string): value is AgentName;

package/dist/src/agent-names.js

@@ -1,5 +1,12 @@
 export const AGENT_NAMES = ['claude', 'codex', 'opencode', 'cursor', 'copilot'];
 export const DEFAULT_AGENT_NAME = 'claude';
+export const AGENT_BINARIES = {
+    claude: 'claude',
+    codex: 'codex',
+    opencode: 'opencode',
+    cursor: 'cursor-agent',
+    copilot: 'copilot',
+};
 export function isAgentName(value) {
     return AGENT_NAMES.includes(value);
 }

package/dist/src/controller/create-generation-endpoint.d.ts

@@ -0,0 +1,3 @@
+import type { GenerationEndpoint, GenerationEndpointOptions, GenerationEndpointRequest, GenerationEndpointResponse } from '../types/contract.js';
+export type { GenerationEndpoint, GenerationEndpointOptions, GenerationEndpointRequest, GenerationEndpointResponse };
+export declare function createGenerationEndpoint(options?: GenerationEndpointOptions): GenerationEndpoint;

package/dist/src/controller/create-generation-endpoint.js

@@ -0,0 +1,15 @@
+import { validateGenerationRequest } from './helpers/validate-generation-request.js';
+import { executeGenerationOrchestrator } from '../orchestrator/execute-generation-orchestrator.js';
+import { createLocalCliAgentInvoker } from '../services/agent/local-cli-agent-invoker.js';
+export function createGenerationEndpoint(options = {}) {
+    const invoker = createLocalCliAgentInvoker({ onDebugEvent: options.onDebugEvent });
+    return {
+        async run(request) {
+            validateGenerationRequest(request);
+            return executeGenerationOrchestrator({ ...request, invoker });
+        },
+        checkAuth(agent) {
+            return invoker.checkAuth(agent);
+        },
+    };
+}

package/dist/src/controller/helpers/validate-generation-request.d.ts

@@ -0,0 +1,2 @@
+import type { GenerationEndpointRequest } from '../../types/contract.js';
+export declare function validateGenerationRequest(request: GenerationEndpointRequest): void;

package/dist/src/controller/helpers/validate-generation-request.js

@@ -0,0 +1,18 @@
+import { isAgentName } from '../../agent-names.js';
+export function validateGenerationRequest(request) {
+    if (request === null || typeof request !== 'object') {
+        throw new TypeError('createGenerationEndpoint requires a request object');
+    }
+    if (!isAgentName(request.agent)) {
+        throw new TypeError(`createGenerationEndpoint requires agent to be a valid agent name, got: ${String(request.agent)}`);
+    }
+    if (typeof request.timeoutMs !== 'number' || request.timeoutMs <= 0) {
+        throw new TypeError('createGenerationEndpoint requires timeoutMs to be a positive number');
+    }
+    if (request.promptOptions === null || typeof request.promptOptions !== 'object') {
+        throw new TypeError('createGenerationEndpoint requires promptOptions to be an object');
+    }
+    if (request.onOutput !== undefined && typeof request.onOutput !== 'function') {
+        throw new TypeError('createGenerationEndpoint requires onOutput to be a function when provided');
+    }
+}

package/dist/src/index.d.ts

@@ -1,9 +1,21 @@
-export { AGENT_NAMES, DEFAULT_AGENT_NAME, isAgentName } from './agent-names.js';
+export { AGENT_NAMES, AGENT_BINARIES, DEFAULT_AGENT_NAME, isAgentName } from './agent-names.js';
 export type { AgentName } from './agent-names.js';
-export { agentSupportsBedrock, buildArgs, checkAgentAuth, describeAgentFailure, extractSentinelOutput, parseMapTokenPropToolCallLines, parseSelectToolCallLines, parseTokenToolCallLines, parseToolCallLines, resolveAgentModel, resolveBinary, runAgent, } from './agent-runner.js';
-export type { AgentAuthStatus, AgentDebugEvent, AgentRunResult, ClassifyComponentCall, ClassifyPropCall, ClassifySlotCall, ExcludePropCall, MapTokenPropCall, ParsedMapTokenPropToolCalls, ParsedSelectToolCalls, ParsedTokenToolCalls, ParsedToolCalls, RejectComponentCall, SelectComponentCall, SelectToolCall, SetGroupCall, SetTokenCall, ToolCall, TokenToolCall, } from './agent-runner.js';
-export { createLocalCliAgentInvoker } from './agent-invoker.js';
-export type { AgentInvoker, CreateLocalCliAgentInvokerOptions, InvokeAgentOptions } from './agent-invoker.js';
-export { buildPrompt, formatCustomPromptBanner, resolveSkillPath } from './prompt-builder.js';
-export type { ComponentSourceRef, GeneratedCdf, Mode, PromptOptions, Skill } from './prompt-builder.js';
+export type { AgentAuthStatus, AgentDebugEvent, AgentRunResult } from './types/agent.js';
+export type { ClassifyComponentCall, ClassifyPropCall, ClassifySlotCall, ExcludePropCall, MapTokenPropCall, ParsedMapTokenPropToolCalls, ParsedSelectToolCalls, ParsedTokenToolCalls, ParsedToolCalls, RejectComponentCall, SelectComponentCall, SelectToolCall, SetGroupCall, SetTokenCall, ToolCall, TokenToolCall, } from './types/tool-calls.js';
+export type { ComponentSourceRef, GeneratedCdf, Mode, PromptOptions, Skill } from './types/prompt.js';
+export { createGenerationEndpoint } from './controller/create-generation-endpoint.js';
+export type { GenerationEndpoint, GenerationEndpointOptions, GenerationEndpointRequest, GenerationEndpointResponse, } from './controller/create-generation-endpoint.js';
+export { executeGenerationOrchestrator } from './orchestrator/execute-generation-orchestrator.js';
+export type { GenerationOrchestratorRequest } from './orchestrator/execute-generation-orchestrator.js';
+export { agentSupportsBedrock, buildAgentArgs as buildArgs, resolveAgentModel, } from './services/agent/helpers/build-agent-args.js';
+export { resolveAgentBinary as resolveBinary } from './services/agent/helpers/resolve-agent-binary.js';
+export { checkAgentAuth } from './services/agent/helpers/check-agent-auth.js';
+export { runAgent, describeAgentFailure, extractSentinelOutput } from './services/agent/run-agent.js';
+export { parsePropToolCallLines as parseToolCallLines } from './services/parsing/parse-prop-tool-calls.js';
+export { parseSelectToolCallLines } from './services/parsing/parse-select-tool-calls.js';
+export { parseTokenToolCallLines } from './services/parsing/parse-token-tool-calls.js';
+export { parseMapTokenPropToolCallLines } from './services/parsing/parse-map-token-tool-calls.js';
+export { buildPrompt, formatCustomPromptBanner, resolveSkillPath } from './services/prompts/build-prompt.js';
 export { formatGenerateProgressLine } from './progress.js';
+export { createLocalCliAgentInvoker } from './services/agent/local-cli-agent-invoker.js';
+export type { AgentInvoker, InvokeAgentOptions, LocalCliAgentInvokerOptions as CreateLocalCliAgentInvokerOptions, } from './types/invoker.js';

package/dist/src/index.js

@@ -1,10 +1,22 @@
 // Agent identity
-export { AGENT_NAMES, DEFAULT_AGENT_NAME, isAgentName } from './agent-names.js';
-// Agent invocation (low-level)
-export { agentSupportsBedrock, buildArgs, checkAgentAuth, describeAgentFailure, extractSentinelOutput, parseMapTokenPropToolCallLines, parseSelectToolCallLines, parseTokenToolCallLines, parseToolCallLines, resolveAgentModel, resolveBinary, runAgent, } from './agent-runner.js';
-// Agent invocation (interface)
-export { createLocalCliAgentInvoker } from './agent-invoker.js';
+export { AGENT_NAMES, AGENT_BINARIES, DEFAULT_AGENT_NAME, isAgentName } from './agent-names.js';
+// Generation endpoint (primary entry point)
+export { createGenerationEndpoint } from './controller/create-generation-endpoint.js';
+// Orchestrator (lower-level — for callers that supply their own invoker)
+export { executeGenerationOrchestrator } from './orchestrator/execute-generation-orchestrator.js';
+// Agent execution (low-level)
+export { agentSupportsBedrock, buildAgentArgs as buildArgs, resolveAgentModel, } from './services/agent/helpers/build-agent-args.js';
+export { resolveAgentBinary as resolveBinary } from './services/agent/helpers/resolve-agent-binary.js';
+export { checkAgentAuth } from './services/agent/helpers/check-agent-auth.js';
+export { runAgent, describeAgentFailure, extractSentinelOutput } from './services/agent/run-agent.js';
+// Tool call parsing
+export { parsePropToolCallLines as parseToolCallLines } from './services/parsing/parse-prop-tool-calls.js';
+export { parseSelectToolCallLines } from './services/parsing/parse-select-tool-calls.js';
+export { parseTokenToolCallLines } from './services/parsing/parse-token-tool-calls.js';
+export { parseMapTokenPropToolCallLines } from './services/parsing/parse-map-token-tool-calls.js';
 // Prompt building
-export { buildPrompt, formatCustomPromptBanner, resolveSkillPath } from './prompt-builder.js';
+export { buildPrompt, formatCustomPromptBanner, resolveSkillPath } from './services/prompts/build-prompt.js';
 // Progress reporting
 export { formatGenerateProgressLine } from './progress.js';
+// Backward-compat exports — CLI callers still use these; migrate to createGenerationEndpoint
+export { createLocalCliAgentInvoker } from './services/agent/local-cli-agent-invoker.js';

package/dist/src/orchestrator/execute-generation-orchestrator.d.ts

@@ -0,0 +1,6 @@
+import type { GenerationEndpointRequest, GenerationEndpointResponse } from '../types/contract.js';
+import type { AgentInvoker } from '../services/agent/local-cli-agent-invoker.js';
+export interface GenerationOrchestratorRequest extends GenerationEndpointRequest {
+    readonly invoker: AgentInvoker;
+}
+export declare function executeGenerationOrchestrator(request: GenerationOrchestratorRequest): Promise<GenerationEndpointResponse>;

package/dist/src/orchestrator/execute-generation-orchestrator.js

@@ -0,0 +1,12 @@
+import { buildPrompt } from '../services/prompts/build-prompt.js';
+export async function executeGenerationOrchestrator(request) {
+    const prompt = await buildPrompt(request.promptOptions);
+    return request.invoker.invoke({
+        agent: request.agent,
+        model: request.model,
+        bedrock: request.bedrock,
+        prompt,
+        timeoutMs: request.timeoutMs,
+        onOutput: request.onOutput,
+    });
+}

package/dist/src/services/agent/helpers/build-agent-args.d.ts

@@ -0,0 +1,6 @@
+import type { AgentName } from '../../../agent-names.js';
+/** Per-agent env vars that switch model calls to AWS Bedrock. */
+export declare const BEDROCK_ENV_BY_AGENT: Partial<Record<AgentName, Record<string, string>>>;
+export declare function agentSupportsBedrock(agent: AgentName): boolean;
+export declare function resolveAgentModel(agent: AgentName, explicit?: string, bedrock?: boolean): string | undefined;
+export declare function buildAgentArgs(agent: AgentName, prompt: string, model?: string, promptViaStdin?: boolean, bedrock?: boolean): string[];

package/dist/src/services/agent/helpers/build-agent-args.js

@@ -0,0 +1,58 @@
+/** Per-agent env vars that switch model calls to AWS Bedrock. */
+export const BEDROCK_ENV_BY_AGENT = {
+    claude: { CLAUDE_CODE_USE_BEDROCK: '1' },
+};
+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';
+const DEFAULT_CODEX_BEDROCK_MODEL = 'openai.gpt-5.6-luna';
+const DEFAULT_MODELS = {
+    claude: 'haiku',
+    opencode: DEFAULT_OPENCODE_MODEL,
+    cursor: 'gpt-mini',
+    copilot: 'Auto',
+};
+function withBedrockProviderPrefix(model) {
+    return model.includes('/') ? model : `amazon-bedrock/${model}`;
+}
+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 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 buildAgentArgs(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/services/agent/helpers/check-agent-auth.d.ts

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

package/dist/src/services/agent/helpers/check-agent-auth.js

@@ -0,0 +1,19 @@
+import { spawn } from 'node:child_process';
+import { resolveAgentBinary } from './resolve-agent-binary.js';
+import { checkClaudeAuth } from './check-claude-auth.js';
+export async function checkAgentAuth(agent) {
+    const binary = resolveAgentBinary(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 checkClaudeAuth(binary);
+}

package/dist/src/services/agent/helpers/check-claude-auth.d.ts

@@ -0,0 +1,2 @@
+import type { AgentAuthStatus } from '../../../types/agent.js';
+export declare function checkClaudeAuth(binary: string): Promise<AgentAuthStatus>;

package/dist/src/services/agent/helpers/check-claude-auth.js

@@ -0,0 +1,37 @@
+import { spawn } from 'node:child_process';
+export function checkClaudeAuth(binary) {
+    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/services/agent/helpers/describe-agent-failure.d.ts

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

package/dist/src/services/agent/helpers/describe-agent-failure.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/services/agent/helpers/extract-sentinel-output.d.ts

@@ -0,0 +1 @@
+export declare function extractSentinelOutput(stdout: string): string | null | 'multiple';

package/dist/src/services/agent/helpers/extract-sentinel-output.js

@@ -0,0 +1,16 @@
+export function extractSentinelOutput(stdout) {
+    const START = '<<<EDS_OUTPUT_START>>>';
+    const END = '<<<EDS_OUTPUT_END>>>';
+    const startIdx = stdout.indexOf(START);
+    const endIdx = stdout.indexOf(END);
+    if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx)
+        return null;
+    const secondStart = stdout.indexOf(START, startIdx + START.length);
+    if (secondStart !== -1 && secondStart < endIdx)
+        return 'multiple';
+    const afterStart = stdout.indexOf(END, startIdx);
+    const secondEnd = stdout.indexOf(END, afterStart + END.length);
+    if (secondEnd !== -1)
+        return 'multiple';
+    return stdout.slice(startIdx + START.length, endIdx).trim();
+}

package/dist/src/services/agent/helpers/resolve-agent-binary.d.ts

@@ -0,0 +1,2 @@
+import { type AgentName } from '../../../agent-names.js';
+export declare function resolveAgentBinary(agent: AgentName): string;

package/dist/src/services/agent/helpers/resolve-agent-binary.js

@@ -0,0 +1,8 @@
+import { AGENT_BINARIES } from '../../../agent-names.js';
+export function resolveAgentBinary(agent) {
+    const envKey = `EDS_AGENT_BINARY_${agent.toUpperCase()}`;
+    const override = process.env[envKey];
+    if (override && override.trim())
+        return override.trim();
+    return AGENT_BINARIES[agent];
+}

package/dist/src/services/agent/local-cli-agent-invoker.d.ts

@@ -0,0 +1,3 @@
+import type { AgentInvoker, InvokeAgentOptions, LocalCliAgentInvokerOptions } from '../../types/invoker.js';
+export type { AgentInvoker, InvokeAgentOptions, LocalCliAgentInvokerOptions };
+export declare function createLocalCliAgentInvoker(options?: LocalCliAgentInvokerOptions): AgentInvoker;

package/dist/src/{agent-invoker.js → services/agent/local-cli-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 { runAgent } from './run-agent.js';
+import { checkAgentAuth } from './helpers/check-agent-auth.js';
 export function createLocalCliAgentInvoker(options = {}) {
     const { onDebugEvent } = options;
     return {

package/dist/src/services/agent/run-agent.d.ts

@@ -0,0 +1,15 @@
+import type { AgentName } from '../../agent-names.js';
+import type { AgentRunResult, AgentDebugEvent } from '../../types/agent.js';
+import { describeAgentFailure } from './helpers/describe-agent-failure.js';
+import { extractSentinelOutput } from './helpers/extract-sentinel-output.js';
+export { describeAgentFailure, extractSentinelOutput };
+export declare function runAgent(options: {
+    agent: AgentName;
+    prompt: string;
+    timeoutMs: number;
+    model?: string;
+    bedrock?: boolean;
+    onOutput?: (chunk: string) => void;
+    promptViaStdin?: boolean;
+    onDebugEvent?: AgentDebugEvent;
+}): Promise<AgentRunResult>;

package/dist/src/services/agent/run-agent.js

@@ -0,0 +1,70 @@
+import { spawn } from 'node:child_process';
+import { resolveAgentBinary } from './helpers/resolve-agent-binary.js';
+import { buildAgentArgs, BEDROCK_ENV_BY_AGENT } from './helpers/build-agent-args.js';
+import { describeAgentFailure } from './helpers/describe-agent-failure.js';
+import { extractSentinelOutput } from './helpers/extract-sentinel-output.js';
+export { describeAgentFailure, extractSentinelOutput };
+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 = resolveAgentBinary(agent);
+    const useStdin = !!promptViaStdin;
+    const args = buildAgentArgs(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 = bedrock ? BEDROCK_ENV_BY_AGENT[agent] : undefined;
+        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;
+        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('close', (code, signal) => {
+            clearTimeout(timer);
+            const result = { exitCode: signal ? 1 : (code ?? 1), stdout, 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/services/parsing/helpers/read-tool-call-objects.d.ts

@@ -0,0 +1,4 @@
+export declare function readToolCallObjects(stdout: string): {
+    objects: Array<Record<string, unknown>>;
+    warnings: string[];
+};

package/dist/src/services/parsing/helpers/read-tool-call-objects.js

@@ -0,0 +1,54 @@
+function findJsonObjectEnd(line) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (escaped) {
+            escaped = false;
+        }
+        else if (ch === '\\' && inString) {
+            escaped = true;
+        }
+        else if (ch === '"') {
+            inString = !inString;
+        }
+        else if (!inString && ch === '{') {
+            depth++;
+        }
+        else if (!inString && ch === '}' && --depth === 0) {
+            return i;
+        }
+    }
+    return -1;
+}
+export function readToolCallObjects(stdout) {
+    const objects = [];
+    const warnings = [];
+    for (const raw of stdout.split('\n')) {
+        const line = raw.trim();
+        if (!line.startsWith('{'))
+            continue;
+        const end = findJsonObjectEnd(line);
+        if (end === -1) {
+            warnings.push(`unparseable line: ${line.slice(0, 120)}`);
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line.slice(0, end + 1));
+        }
+        catch {
+            warnings.push(`unparseable line: ${line.slice(0, 120)}`);
+            continue;
+        }
+        const trailing = line.slice(end + 1);
+        if (trailing.trim()) {
+            warnings.push(`ignored trailing content after JSON: ${trailing.trim().slice(0, 120)}`);
+        }
+        if (typeof parsed === 'object' && parsed !== null && 'tool' in parsed) {
+            objects.push(parsed);
+        }
+    }
+    return { objects, warnings };
+}

package/dist/src/services/parsing/parse-map-token-tool-calls.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedMapTokenPropToolCalls } from '../../types/tool-calls.js';
+export declare function parseMapTokenPropToolCallLines(stdout: string): ParsedMapTokenPropToolCalls;

package/dist/src/services/parsing/parse-map-token-tool-calls.js

@@ -0,0 +1,39 @@
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((v) => typeof v === 'string');
+}
+export function parseMapTokenPropToolCallLines(stdout) {
+    const calls = [];
+    const warnings = [];
+    for (const raw of stdout.split('\n')) {
+        const line = raw.trim();
+        if (!line.startsWith('{'))
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            warnings.push(`unparseable line: ${line.slice(0, 120)}`);
+            continue;
+        }
+        if (typeof obj !== 'object' || obj === null || !('tool' in obj))
+            continue;
+        const rec = obj;
+        if (rec.tool !== 'map_token_prop')
+            continue;
+        if (typeof rec.component !== 'string' || !rec.component) {
+            warnings.push('map_token_prop missing component — skipped');
+            continue;
+        }
+        if (typeof rec.prop !== 'string' || !rec.prop) {
+            warnings.push(`map_token_prop '${rec.component}': missing prop — skipped`);
+            continue;
+        }
+        if (!isStringArray(rec.token_allowed) || rec.token_allowed.length === 0) {
+            warnings.push(`map_token_prop '${rec.component}.${String(rec.prop)}': missing or empty token_allowed — skipped`);
+            continue;
+        }
+        calls.push({ tool: 'map_token_prop', component: rec.component, prop: rec.prop, token_allowed: rec.token_allowed });
+    }
+    return { calls, warnings };
+}

package/dist/src/services/parsing/parse-prop-tool-calls.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedToolCalls } from '../../types/tool-calls.js';
+export declare function parsePropToolCallLines(stdout: string): ParsedToolCalls;