@renseiai/agentfactory 0.8.0

package/dist/src/providers/codex-provider.test.js

@@ -0,0 +1,387 @@
+import { describe, it, expect } from 'vitest';
+import { mapCodexEvent, mapCodexItemEvent, } from './codex-provider.js';
+function freshState() {
+    return {
+        sessionId: null,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        turnCount: 0,
+    };
+}
+describe('mapCodexEvent', () => {
+    it('maps thread.started to init', () => {
+        const state = freshState();
+        const event = { type: 'thread.started', thread_id: 'thread-abc' };
+        const result = mapCodexEvent(event, state);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({
+            type: 'init',
+            sessionId: 'thread-abc',
+        });
+        expect(state.sessionId).toBe('thread-abc');
+    });
+    it('maps turn.started to system with incrementing turn count', () => {
+        const state = freshState();
+        const event = { type: 'turn.started' };
+        const r1 = mapCodexEvent(event, state);
+        expect(r1[0]).toMatchObject({
+            type: 'system',
+            subtype: 'turn_started',
+            message: 'Turn 1 started',
+        });
+        expect(state.turnCount).toBe(1);
+        const r2 = mapCodexEvent(event, state);
+        expect(r2[0]).toMatchObject({ message: 'Turn 2 started' });
+        expect(state.turnCount).toBe(2);
+    });
+    it('maps turn.completed to result with accumulated usage', () => {
+        const state = freshState();
+        state.turnCount = 1;
+        const event = {
+            type: 'turn.completed',
+            usage: { input_tokens: 100, output_tokens: 50, cached_input_tokens: 20 },
+        };
+        const result = mapCodexEvent(event, state);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({
+            type: 'result',
+            success: true,
+            cost: {
+                inputTokens: 100,
+                outputTokens: 50,
+                numTurns: 1,
+            },
+        });
+        expect(state.totalInputTokens).toBe(100);
+        expect(state.totalOutputTokens).toBe(50);
+    });
+    it('accumulates usage across multiple turns', () => {
+        const state = freshState();
+        state.turnCount = 2;
+        mapCodexEvent({ type: 'turn.completed', usage: { input_tokens: 100, output_tokens: 50 } }, state);
+        const result = mapCodexEvent({ type: 'turn.completed', usage: { input_tokens: 200, output_tokens: 80 } }, state);
+        expect(result[0]).toMatchObject({
+            type: 'result',
+            success: true,
+            cost: { inputTokens: 300, outputTokens: 130 },
+        });
+    });
+    it('maps turn.completed without usage', () => {
+        const state = freshState();
+        const result = mapCodexEvent({ type: 'turn.completed' }, state);
+        expect(result[0]).toMatchObject({ type: 'result', success: true });
+    });
+    it('maps turn.failed to failed result', () => {
+        const state = freshState();
+        const event = {
+            type: 'turn.failed',
+            error: { message: 'Model error' },
+        };
+        const result = mapCodexEvent(event, state);
+        expect(result[0]).toMatchObject({
+            type: 'result',
+            success: false,
+            errors: ['Model error'],
+            errorSubtype: 'turn_failed',
+        });
+    });
+    it('maps turn.failed without error message', () => {
+        const state = freshState();
+        const result = mapCodexEvent({ type: 'turn.failed' }, state);
+        expect(result[0]).toMatchObject({
+            type: 'result',
+            success: false,
+            errors: ['Turn failed'],
+        });
+    });
+    it('maps error event', () => {
+        const state = freshState();
+        const event = { type: 'error', message: 'Connection lost' };
+        const result = mapCodexEvent(event, state);
+        expect(result[0]).toMatchObject({
+            type: 'error',
+            message: 'Connection lost',
+        });
+    });
+    it('maps error event without message', () => {
+        const state = freshState();
+        const result = mapCodexEvent({ type: 'error' }, state);
+        expect(result[0]).toMatchObject({
+            type: 'error',
+            message: 'Unknown error',
+        });
+    });
+    it('delegates item events to mapCodexItemEvent', () => {
+        const state = freshState();
+        const event = {
+            type: 'item.completed',
+            item: { id: 'msg-1', type: 'agent_message', text: 'Hello' },
+        };
+        const result = mapCodexEvent(event, state);
+        expect(result[0]).toMatchObject({
+            type: 'assistant_text',
+            text: 'Hello',
+        });
+    });
+    it('handles unknown event type gracefully', () => {
+        const state = freshState();
+        const event = { type: 'unknown.event' };
+        const result = mapCodexEvent(event, state);
+        expect(result[0]).toMatchObject({
+            type: 'system',
+            subtype: 'unknown',
+        });
+    });
+});
+describe('mapCodexItemEvent', () => {
+    it('maps agent_message to assistant_text', () => {
+        const event = {
+            type: 'item.completed',
+            item: { id: 'msg-1', type: 'agent_message', text: 'Analysis complete' },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result).toEqual([{
+                type: 'assistant_text',
+                text: 'Analysis complete',
+                raw: event,
+            }]);
+    });
+    it('maps reasoning to system event', () => {
+        const event = {
+            type: 'item.completed',
+            item: { id: 'r-1', type: 'reasoning', text: 'Thinking about the problem...' },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result[0]).toMatchObject({
+            type: 'system',
+            subtype: 'reasoning',
+            message: 'Thinking about the problem...',
+        });
+    });
+    it('maps command_execution item.started to tool_use', () => {
+        const event = {
+            type: 'item.started',
+            item: {
+                id: 'cmd-1',
+                type: 'command_execution',
+                command: 'ls -la',
+                aggregated_output: '',
+                status: 'in_progress',
+            },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result[0]).toMatchObject({
+            type: 'tool_use',
+            toolName: 'shell',
+            toolUseId: 'cmd-1',
+            input: { command: 'ls -la' },
+        });
+    });
+    it('maps command_execution item.completed to tool_result', () => {
+        const event = {
+            type: 'item.completed',
+            item: {
+                id: 'cmd-1',
+                type: 'command_execution',
+                command: 'ls -la',
+                aggregated_output: 'file1.txt\nfile2.txt',
+                exit_code: 0,
+                status: 'completed',
+            },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result[0]).toMatchObject({
+            type: 'tool_result',
+            toolName: 'shell',
+            toolUseId: 'cmd-1',
+            content: 'file1.txt\nfile2.txt',
+            isError: false,
+        });
+    });
+    it('marks command_execution as error on non-zero exit code', () => {
+        const event = {
+            type: 'item.completed',
+            item: {
+                id: 'cmd-1',
+                type: 'command_execution',
+                command: 'false',
+                aggregated_output: '',
+                exit_code: 1,
+                status: 'failed',
+            },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result[0]).toMatchObject({
+            type: 'tool_result',
+            isError: true,
+        });
+    });
+    it('maps command_execution item.updated to progress', () => {
+        const event = {
+            type: 'item.updated',
+            item: {
+                id: 'cmd-1',
+                type: 'command_execution',
+                command: 'npm install',
+                aggregated_output: 'Installing...',
+                status: 'in_progress',
+            },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result[0]).toMatchObject({
+            type: 'system',
+            subtype: 'command_progress',
+            message: 'Command: npm install (in_progress)',
+        });
+    });
+    it('maps file_change to tool_result', () => {
+        const event = {
+            type: 'item.completed',
+            item: {
+                id: 'fc-1',
+                type: 'file_change',
+                changes: [
+                    { path: 'src/index.ts', kind: 'update' },
+                    { path: 'src/new.ts', kind: 'add' },
+                ],
+                status: 'completed',
+            },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result[0]).toMatchObject({
+            type: 'tool_result',
+            toolName: 'file_change',
+            content: 'update: src/index.ts\nadd: src/new.ts',
+            isError: false,
+        });
+    });
+    it('maps mcp_tool_call item.started to tool_use', () => {
+        const event = {
+            type: 'item.started',
+            item: {
+                id: 'mcp-1',
+                type: 'mcp_tool_call',
+                server: 'linear',
+                tool: 'create_issue',
+                arguments: { title: 'Test' },
+                status: 'in_progress',
+            },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result[0]).toMatchObject({
+            type: 'tool_use',
+            toolName: 'mcp:linear/create_issue',
+            toolUseId: 'mcp-1',
+            input: { title: 'Test' },
+        });
+    });
+    it('maps mcp_tool_call item.completed to tool_result', () => {
+        const event = {
+            type: 'item.completed',
+            item: {
+                id: 'mcp-1',
+                type: 'mcp_tool_call',
+                server: 'linear',
+                tool: 'create_issue',
+                arguments: { title: 'Test' },
+                result: { content: [{ text: 'Created' }] },
+                status: 'completed',
+            },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result[0]).toMatchObject({
+            type: 'tool_result',
+            toolName: 'mcp:linear/create_issue',
+            content: '[{"text":"Created"}]',
+            isError: false,
+        });
+    });
+    it('maps mcp_tool_call error', () => {
+        const event = {
+            type: 'item.completed',
+            item: {
+                id: 'mcp-1',
+                type: 'mcp_tool_call',
+                server: 'linear',
+                tool: 'create_issue',
+                arguments: {},
+                error: { message: 'Auth failed' },
+                status: 'failed',
+            },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result[0]).toMatchObject({
+            type: 'tool_result',
+            isError: true,
+            content: 'Auth failed',
+        });
+    });
+    it('returns empty array for mcp_tool_call item.updated', () => {
+        const event = {
+            type: 'item.updated',
+            item: {
+                id: 'mcp-1',
+                type: 'mcp_tool_call',
+                server: 'linear',
+                tool: 'create_issue',
+                arguments: {},
+                status: 'in_progress',
+            },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result).toEqual([]);
+    });
+    it('maps todo_list to system event', () => {
+        const event = {
+            type: 'item.completed',
+            item: {
+                id: 'todo-1',
+                type: 'todo_list',
+                items: [
+                    { text: 'Read files', completed: true },
+                    { text: 'Write tests', completed: false },
+                ],
+            },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result[0]).toMatchObject({
+            type: 'system',
+            subtype: 'todo_list',
+            message: '[x] Read files\n[ ] Write tests',
+        });
+    });
+    it('maps error item to error event', () => {
+        const event = {
+            type: 'item.completed',
+            item: { id: 'err-1', type: 'error', message: 'Something went wrong' },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result[0]).toMatchObject({
+            type: 'error',
+            message: 'Something went wrong',
+        });
+    });
+    it('handles unknown item type', () => {
+        const event = {
+            type: 'item.completed',
+            item: { id: 'x', type: 'web_search' },
+        };
+        const result = mapCodexItemEvent(event);
+        expect(result[0]).toMatchObject({
+            type: 'system',
+            subtype: 'unknown_item',
+        });
+    });
+});
+describe('CodexProvider', () => {
+    it('exports CodexProvider class', async () => {
+        const { CodexProvider } = await import('./codex-provider.js');
+        const provider = new CodexProvider();
+        expect(provider.name).toBe('codex');
+    });
+    it('exports createCodexProvider factory', async () => {
+        const { createCodexProvider } = await import('./codex-provider.js');
+        const provider = createCodexProvider();
+        expect(provider.name).toBe('codex');
+    });
+});

package/dist/src/providers/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Agent Provider Factory
+ *
+ * Creates provider instances based on name.
+ * Supports provider selection via env vars:
+ *   AGENT_PROVIDER=claude            (global default)
+ *   AGENT_PROVIDER_SOCIAL=codex      (per-project override)
+ *   AGENT_PROVIDER_QA=amp            (per-work-type override)
+ *
+ * Resolution order: work-type → project → env default → 'claude'
+ */
+export type { AgentProviderName, AgentProvider, AgentSpawnConfig, AgentHandle, AgentEvent } from './types.js';
+export type { AgentInitEvent, AgentSystemEvent, AgentAssistantTextEvent, AgentToolUseEvent, AgentToolResultEvent, AgentToolProgressEvent, AgentResultEvent, AgentErrorEvent, AgentCostData, } from './types.js';
+export { ClaudeProvider, createClaudeProvider } from './claude-provider.js';
+export { CodexProvider, createCodexProvider } from './codex-provider.js';
+export { AmpProvider, createAmpProvider } from './amp-provider.js';
+export { SpringAiProvider, createSpringAiProvider } from './spring-ai-provider.js';
+export { A2aProvider, createA2aProvider } from './a2a-provider.js';
+import type { AgentProvider, AgentProviderName } from './types.js';
+/**
+ * Create a provider instance by name.
+ *
+ * @param name - Provider name ('claude', 'codex', 'amp', 'spring-ai', 'a2a')
+ * @returns AgentProvider instance
+ * @throws Error if provider name is unknown
+ */
+export declare function createProvider(name: AgentProviderName): AgentProvider;
+/**
+ * Resolve which provider to use based on env vars, project, and work type.
+ *
+ * Resolution order (highest priority first):
+ * 1. AGENT_PROVIDER_{WORKTYPE} (e.g., AGENT_PROVIDER_QA=amp)
+ * 2. AGENT_PROVIDER_{PROJECT} (e.g., AGENT_PROVIDER_SOCIAL=codex)
+ * 3. AGENT_PROVIDER (global default)
+ * 4. 'claude' (fallback)
+ *
+ * @param options - Project and work type context for resolution
+ * @returns The resolved provider name
+ */
+export declare function resolveProviderName(options?: {
+    project?: string;
+    workType?: string;
+}): AgentProviderName;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,YAAY,EAAE,iBAAiB,EAAE,aAAa,EAAE,gBAAgB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAC7G,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,EACtB,gBAAgB,EAChB,eAAe,EACf,aAAa,GACd,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAC3E,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AACxE,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAClE,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA;AAClF,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAElE,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAOlE;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,iBAAiB,GAAG,aAAa,CAerE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,GAAG,iBAAiB,CA2BpB"}

package/dist/src/providers/index.js

@@ -0,0 +1,85 @@
+/**
+ * Agent Provider Factory
+ *
+ * Creates provider instances based on name.
+ * Supports provider selection via env vars:
+ *   AGENT_PROVIDER=claude            (global default)
+ *   AGENT_PROVIDER_SOCIAL=codex      (per-project override)
+ *   AGENT_PROVIDER_QA=amp            (per-work-type override)
+ *
+ * Resolution order: work-type → project → env default → 'claude'
+ */
+export { ClaudeProvider, createClaudeProvider } from './claude-provider.js';
+export { CodexProvider, createCodexProvider } from './codex-provider.js';
+export { AmpProvider, createAmpProvider } from './amp-provider.js';
+export { SpringAiProvider, createSpringAiProvider } from './spring-ai-provider.js';
+export { A2aProvider, createA2aProvider } from './a2a-provider.js';
+import { ClaudeProvider } from './claude-provider.js';
+import { CodexProvider } from './codex-provider.js';
+import { AmpProvider } from './amp-provider.js';
+import { SpringAiProvider } from './spring-ai-provider.js';
+import { A2aProvider } from './a2a-provider.js';
+/**
+ * Create a provider instance by name.
+ *
+ * @param name - Provider name ('claude', 'codex', 'amp', 'spring-ai', 'a2a')
+ * @returns AgentProvider instance
+ * @throws Error if provider name is unknown
+ */
+export function createProvider(name) {
+    switch (name) {
+        case 'claude':
+            return new ClaudeProvider();
+        case 'codex':
+            return new CodexProvider();
+        case 'amp':
+            return new AmpProvider();
+        case 'spring-ai':
+            return new SpringAiProvider();
+        case 'a2a':
+            return new A2aProvider();
+        default:
+            throw new Error(`Unknown agent provider: ${name}. Supported: claude, codex, amp, spring-ai, a2a`);
+    }
+}
+/**
+ * Resolve which provider to use based on env vars, project, and work type.
+ *
+ * Resolution order (highest priority first):
+ * 1. AGENT_PROVIDER_{WORKTYPE} (e.g., AGENT_PROVIDER_QA=amp)
+ * 2. AGENT_PROVIDER_{PROJECT} (e.g., AGENT_PROVIDER_SOCIAL=codex)
+ * 3. AGENT_PROVIDER (global default)
+ * 4. 'claude' (fallback)
+ *
+ * @param options - Project and work type context for resolution
+ * @returns The resolved provider name
+ */
+export function resolveProviderName(options) {
+    // Check work-type-specific override
+    if (options?.workType) {
+        const workTypeKey = `AGENT_PROVIDER_${options.workType.toUpperCase().replace(/-/g, '_')}`;
+        const workTypeProvider = process.env[workTypeKey];
+        if (workTypeProvider && isValidProviderName(workTypeProvider)) {
+            return workTypeProvider;
+        }
+    }
+    // Check project-specific override
+    if (options?.project) {
+        const projectKey = `AGENT_PROVIDER_${options.project.toUpperCase()}`;
+        const projectProvider = process.env[projectKey];
+        if (projectProvider && isValidProviderName(projectProvider)) {
+            return projectProvider;
+        }
+    }
+    // Check global default
+    const globalProvider = process.env.AGENT_PROVIDER;
+    if (globalProvider && isValidProviderName(globalProvider)) {
+        return globalProvider;
+    }
+    // Fallback
+    return 'claude';
+}
+const VALID_PROVIDER_NAMES = ['claude', 'codex', 'amp', 'spring-ai', 'a2a'];
+function isValidProviderName(name) {
+    return VALID_PROVIDER_NAMES.includes(name);
+}

package/dist/src/providers/spring-ai-provider.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Spring AI Agent Provider
+ *
+ * Spawns a Spring AI agent JAR as a child process and parses its JSONL event
+ * stream into normalized AgentEvents.
+ *
+ * CLI invocation patterns:
+ *   New session:  java -jar <JAR> --prompt "<prompt>" --cwd <cwd> --json
+ *   Resume:       java -jar <JAR> --resume <sessionId> --prompt "<prompt>" --cwd <cwd> --json
+ *
+ * JSONL event types:
+ *   session.started   → init (sessionId)
+ *   turn.started      → system (turn_started)
+ *   turn.completed    → result (success, usage)
+ *   turn.failed       → result (failure)
+ *   tool.invocation   → tool_use
+ *   tool.result       → tool_result
+ *   assistant.message  → assistant_text
+ *   error             → error
+ */
+import type { AgentProvider, AgentSpawnConfig, AgentHandle, AgentEvent } from './types.js';
+interface SpringAiSessionStarted {
+    type: 'session.started';
+    session_id: string;
+}
+interface SpringAiTurnStarted {
+    type: 'turn.started';
+}
+interface SpringAiTurnCompleted {
+    type: 'turn.completed';
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+        model?: string;
+    };
+}
+interface SpringAiTurnFailed {
+    type: 'turn.failed';
+    error?: {
+        message?: string;
+        code?: string;
+    };
+}
+interface SpringAiAssistantMessage {
+    type: 'assistant.message';
+    id?: string;
+    text: string;
+}
+interface SpringAiToolInvocation {
+    type: 'tool.invocation';
+    id: string;
+    tool_name: string;
+    input: Record<string, unknown>;
+}
+interface SpringAiToolResult {
+    type: 'tool.result';
+    id: string;
+    tool_name?: string;
+    content: string;
+    is_error: boolean;
+}
+interface SpringAiErrorEvent {
+    type: 'error';
+    message?: string;
+    code?: string;
+}
+export type SpringAiEvent = SpringAiSessionStarted | SpringAiTurnStarted | SpringAiTurnCompleted | SpringAiTurnFailed | SpringAiAssistantMessage | SpringAiToolInvocation | SpringAiToolResult | SpringAiErrorEvent;
+export interface SpringAiEventMapperState {
+    sessionId: string | null;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    turnCount: number;
+}
+/**
+ * Map a single Spring AI JSONL event to one or more normalized AgentEvents.
+ * Exported for unit testing — the AgentHandle uses this internally.
+ */
+export declare function mapSpringAiEvent(event: SpringAiEvent, state: SpringAiEventMapperState): AgentEvent[];
+export declare class SpringAiProvider implements AgentProvider {
+    readonly name: "spring-ai";
+    spawn(config: AgentSpawnConfig): AgentHandle;
+    resume(sessionId: string, config: AgentSpawnConfig): AgentHandle;
+    private createHandle;
+}
+/**
+ * Create a new Spring AI provider instance
+ */
+export declare function createSpringAiProvider(): SpringAiProvider;
+export {};
+//# sourceMappingURL=spring-ai-provider.d.ts.map

package/dist/src/providers/spring-ai-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring-ai-provider.d.ts","sourceRoot":"","sources":["../../../src/providers/spring-ai-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,UAAU,EACX,MAAM,YAAY,CAAA;AAMnB,UAAU,sBAAsB;IAC9B,IAAI,EAAE,iBAAiB,CAAA;IACvB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,UAAU,mBAAmB;IAC3B,IAAI,EAAE,cAAc,CAAA;CACrB;AAED,UAAU,qBAAqB;IAC7B,IAAI,EAAE,gBAAgB,CAAA;IACtB,KAAK,CAAC,EAAE;QACN,YAAY,CAAC,EAAE,MAAM,CAAA;QACrB,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,CAAA;CACF;AAED,UAAU,kBAAkB;IAC1B,IAAI,EAAE,aAAa,CAAA;IACnB,KAAK,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAC5C;AAED,UAAU,wBAAwB;IAChC,IAAI,EAAE,mBAAmB,CAAA;IACzB,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb;AAED,UAAU,sBAAsB;IAC9B,IAAI,EAAE,iBAAiB,CAAA;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAED,UAAU,kBAAkB;IAC1B,IAAI,EAAE,aAAa,CAAA;IACnB,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED,UAAU,kBAAkB;IAC1B,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,MAAM,aAAa,GACrB,sBAAsB,GACtB,mBAAmB,GACnB,qBAAqB,GACrB,kBAAkB,GAClB,wBAAwB,GACxB,sBAAsB,GACtB,kBAAkB,GAClB,kBAAkB,CAAA;AAMtB,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,gBAAgB,EAAE,MAAM,CAAA;IACxB,iBAAiB,EAAE,MAAM,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,wBAAwB,GAC9B,UAAU,EAAE,CAsFd;AAMD,qBAAa,gBAAiB,YAAW,aAAa;IACpD,QAAQ,CAAC,IAAI,EAAG,WAAW,CAAS;IAEpC,KAAK,CAAC,MAAM,EAAE,gBAAgB,GAAG,WAAW;IAI5C,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,WAAW;IAIhE,OAAO,CAAC,YAAY;CA4DrB;AAoKD;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAEzD"}

package/dist/src/providers/spring-ai-provider.integration.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Integration tests for Spring AI Provider
+ *
+ * Tests the full provider lifecycle using mock subprocess that emits
+ * Spring AI JSONL events, covering:
+ * - Happy path spawn + complete
+ * - Session resume
+ * - Error handling (missing JAR, missing Java, agent crash)
+ * - Cost data extraction accuracy
+ * - Tool permission adapter output
+ */
+export {};
+//# sourceMappingURL=spring-ai-provider.integration.test.d.ts.map

package/dist/src/providers/spring-ai-provider.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring-ai-provider.integration.test.d.ts","sourceRoot":"","sources":["../../../src/providers/spring-ai-provider.integration.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}