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

package/dist/package.json

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

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

@@ -0,0 +1,25 @@
+import type { AgentDebugEvent, AgentAuthStatus, AgentName, AgentRunResult } from './agent-runner.js';
+export interface InvokeAgentOptions {
+    agent: AgentName;
+    model?: string;
+    bedrock?: boolean;
+    prompt: string;
+    timeoutMs: number;
+    onOutput?: (chunk: string) => void;
+}
+/**
+ * Abstracts "invoke an agent and get a result back" from the local-subprocess
+ * mechanism `runAgent` uses today. A remote implementation (e.g. against an
+ * internal agents service) implements the same contract without importing
+ * this package's subprocess transport.
+ */
+export interface AgentInvoker {
+    invoke(options: InvokeAgentOptions): Promise<AgentRunResult>;
+    checkAuth(agent: AgentName): Promise<AgentAuthStatus>;
+}
+export interface CreateLocalCliAgentInvokerOptions {
+    /** Wire in a debug-event sink (e.g. the CLI's own debug logger). No-op by default. */
+    onDebugEvent?: AgentDebugEvent;
+}
+/** Default `AgentInvoker`: spawns the agent CLI binary as a local subprocess. */
+export declare function createLocalCliAgentInvoker(options?: CreateLocalCliAgentInvokerOptions): AgentInvoker;

package/dist/src/{services/agent/local-cli-agent-invoker.js → agent-invoker.js}

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

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

@@ -1,5 +1,4 @@
 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,12 +1,5 @@
 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/agent-runner.d.ts

@@ -0,0 +1,144 @@
+import type { AgentName } from './agent-names.js';
+export { AGENT_NAMES, DEFAULT_AGENT_NAME, isAgentName, type AgentName } from './agent-names.js';
+export interface AgentRunResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+}
+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 declare function parseSelectToolCallLines(stdout: string): ParsedSelectToolCalls;
+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 declare function parseToolCallLines(stdout: string): ParsedToolCalls;
+export declare function parseTokenToolCallLines(stdout: string): ParsedTokenToolCalls;
+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[];
+}
+export declare function parseMapTokenPropToolCallLines(stdout: string): ParsedMapTokenPropToolCalls;
+export declare function resolveBinary(agent: AgentName): string;
+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 (mirrors the
+ * `EDS_AGENT_BINARY_<AGENT>` pattern), otherwise the lightweight default for
+ * that agent. `bedrock` only affects the fallback default, and only for
+ * agents whose model id changes shape under Bedrock (codex, opencode) — an
+ * explicit value or env override is never rewritten.
+ */
+export declare function resolveAgentModel(agent: AgentName, explicit?: string, bedrock?: boolean): string | undefined;
+export type AgentDebugEvent = (name: string, payload?: Record<string, unknown>) => void;
+export declare function buildArgs(agent: AgentName, prompt: string, model?: string, promptViaStdin?: boolean, bedrock?: boolean): string[];
+export declare function runAgent(options: {
+    agent: AgentName;
+    prompt: string;
+    timeoutMs: number;
+    model?: string;
+    /** Apply the selected agent's Bedrock-routing env vars when enabled. */
+    bedrock?: boolean;
+    onOutput?: (chunk: string) => void;
+    /**
+     * Deliver the prompt on stdin instead of as an argv positional. Required for
+     * large prompts (e.g. the composition resolver inlining candidate files),
+     * which overflow ARG_MAX when passed as an argument.
+     */
+    promptViaStdin?: boolean;
+    /** Optional debug-event sink; callers own how/where events get logged. */
+    onDebugEvent?: AgentDebugEvent;
+}): Promise<AgentRunResult>;
+export type AgentAuthStatus = 'ok' | 'unauthenticated' | 'not-found';
+export declare function checkAgentAuth(agent: AgentName): Promise<AgentAuthStatus>;
+/**
+ * Build a diagnostic string from a failed agent run, surfacing the agent's own
+ * stderr (or stdout, when stderr is empty) so callers never emit a context-free
+ * "agent failed". Callers only invoke this on a failed run: either a non-zero
+ * exit, or a zero exit that produced no tool calls. A non-zero exit is reported
+ * as such; a zero exit is therefore the "produced no tool calls" case.
+ */
+export declare function describeAgentFailure(result: AgentRunResult, maxDetail?: number): string;
+export declare function extractSentinelOutput(stdout: string): string | null | 'multiple';