groundswell 0.0.2 → 1.0.0

package/dist/types/events.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=events.js.map

package/dist/types/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/types/events.ts"],"names":[],"mappings":""}

package/dist/types/harnesses.d.ts

@@ -0,0 +1,474 @@
+import type { Tool, MCPServer, Skill } from './sdk-primitives.js';
+import type { AgentResponse } from './agent.js';
+import type { StreamEvent } from './streaming.js';
+/**
+ * Harness identifier (PRD §7.2).
+ *
+ * The agent runtime/SDK that drives prompting, tool execution, streaming, and
+ * sessions. This axis is ORTHOGONAL to the LLM provider/model — the two are
+ * chosen independently (PRD §7). The harness NEVER appears in the model string.
+ */
+export type HarnessId = 'pi' | 'claude-code';
+/**
+ * LLM host / model provider (PRD §7.8).
+ *
+ * Open set: the well-known providers get IDE autocomplete via the `(string & {})`
+ * idiom, but ANY provider string is valid (e.g. a custom provider registered with a
+ * harness's model registry). This is the LLM vendor axis — NOT the harness.
+ */
+export type ModelProviderId = 'anthropic' | 'openai' | 'google' | 'zai' | (string & {});
+/**
+ * Harness capability flags (PRD §7.4). Identical shape to the legacy
+ * ProviderCapabilities. Unsupported features are advertised here rather than
+ * silently degrading (PRD §7.14).
+ */
+export interface HarnessCapabilities {
+    /** MCP server connections */
+    mcp: boolean;
+    /** Skill loading */
+    skills: boolean;
+    /** Language Server Protocol integration */
+    lsp: boolean;
+    /** Streaming responses */
+    streaming: boolean;
+    /** Session-based state */
+    sessions: boolean;
+    /** Extended thinking/reasoning */
+    extendedThinking: boolean;
+}
+/**
+ * Harness-level configuration options (PRD §7.5).
+ *
+ * Intentionally SLIMMED relative to the legacy ProviderOptions: the session-store
+ * fields (sessionStore, sessionPersistence, sessionTtl, sessionPath) are adapter
+ * internals and live on the concrete harness, not on the shared harness contract
+ * (system_context.md §3 / §7 risk note). `apiKey` is forwarded to the LLM provider
+ * — it is not owned by the harness.
+ *
+ * Harness implementations MAY extend this with harness-specific fields (e.g.
+ * `skillsDirs?: string[]` on a `pi` adapter) per PRD §7.5.
+ *
+ * @example
+ * ```ts
+ * const options: HarnessOptions = {
+ *   endpoint: 'https://api.anthropic.com',
+ *   apiKey: process.env.ANTHROPIC_API_KEY,
+ *   timeout: 60000,
+ * };
+ * ```
+ */
+export interface HarnessOptions {
+    /** API endpoint override */
+    endpoint?: string;
+    /** API key (forwarded to the LLM provider) */
+    apiKey?: string;
+    /** Session/resume id */
+    sessionId?: string;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Custom headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Hook events adapted from AgentHooks to harness-specific lifecycle (PRD §7.11).
+ * Identical to the legacy ProviderHookEvents.
+ *
+ * @example
+ * ```ts
+ * const hooks: HarnessHookEvents = {
+ *   onToolStart: async (tool) => { console.log('Starting:', tool.name); },
+ *   onToolEnd: async (tool, result, duration) => {
+ *     console.log(`Finished ${tool.name} in ${duration}ms`);
+ *   },
+ *   onStream: (chunk) => process.stdout.write(chunk),
+ * };
+ * ```
+ */
+export interface HarnessHookEvents {
+    /** Called before tool execution */
+    onToolStart?: (tool: ToolExecutionRequest) => Promise<void> | void;
+    /** Called after tool execution */
+    onToolEnd?: (tool: ToolExecutionRequest, result: ToolExecutionResult, duration: number) => Promise<void> | void;
+    /** Called when provider session starts */
+    onSessionStart?: () => Promise<void> | void;
+    /** Called when provider session ends */
+    onSessionEnd?: (totalDuration: number) => Promise<void> | void;
+    /** Called for each streaming chunk */
+    onStream?: (chunk: string) => void;
+}
+/**
+ * Tool execution request (PRD §7.10). Copied VERBATIM from providers.ts.
+ * Tools are executed locally via MCPHandler regardless of harness.
+ *
+ * @example
+ * ```ts
+ * const request: ToolExecutionRequest = {
+ *   name: 'filesystem__read_file',
+ *   input: { path: '/src/index.ts' },
+ * };
+ * ```
+ */
+export interface ToolExecutionRequest {
+    /** Tool name (may be namespaced: "server__tool") */
+    name: string;
+    /** Tool input parameters */
+    input: unknown;
+}
+/**
+ * Tool execution result (PRD §7.10). Copied VERBATIM from providers.ts.
+ *
+ * @example
+ * ```ts
+ * const result: ToolExecutionResult = {
+ *   content: 'const x = 1;',
+ *   isError: false,
+ * };
+ * ```
+ */
+export interface ToolExecutionResult {
+    /** Result content */
+    content: string | unknown;
+    /** Whether the execution resulted in an error */
+    isError: boolean;
+}
+/**
+ * Execution options carried inside a {@link HarnessRequest} (PRD §7.3 + §7.10).
+ * Mirrors the legacy ProviderExecutionOptions; named separately for adapter reuse.
+ *
+ * @example
+ * ```ts
+ * const execOptions: HarnessExecutionOptions = {
+ *   model: 'anthropic/claude-sonnet-4-20250514',
+ *   systemPrompt: 'You are a helpful assistant.',
+ *   tools: [myTool],
+ *   hooks: myHooks,
+ *   streaming: true,
+ * };
+ * ```
+ */
+export interface HarnessExecutionOptions {
+    /** Model identifier ("provider/model" or plain — never harness-qualified; PRD §7.8) */
+    model?: string;
+    /** System prompt override */
+    systemPrompt?: string;
+    /** Available tools */
+    tools?: Tool[];
+    /** Lifecycle hooks */
+    hooks?: HarnessHookEvents;
+    /** Session identifier for session-based harnesses */
+    sessionId?: string;
+    /** Enable streaming mode (returns AsyncGenerator instead of a complete response) */
+    streaming?: boolean;
+}
+/**
+ * Harness execution request (PRD §7.3). Merges the legacy ProviderRequest +
+ * ProviderExecutionOptions (system_context.md §3 mapping).
+ *
+ * @example
+ * ```ts
+ * const request: HarnessRequest = {
+ *   prompt: 'Explain TypeScript generics',
+ *   options: { model: 'claude-sonnet-4', streaming: false },
+ * };
+ * ```
+ */
+export interface HarnessRequest {
+    /** The user prompt/message */
+    prompt: string;
+    /** Execution options */
+    options: HarnessExecutionOptions;
+}
+/**
+ * Parsed model identifier (PRD §7.8).
+ *
+ * `provider` is the LLM host (ModelProviderId) — NEVER the harness. Format is
+ * `provider/model` (e.g. `anthropic/claude-sonnet-4-20250514`) or a plain model id
+ * resolved against the configured `defaultModelProvider`.
+ *
+ * NOTE: Defined here (in S1) rather than S2 because {@link Harness.normalizeModel}
+ * references it and must compile. S2 (P1.M1.T1.S2) adds GlobalHarnessConfig +
+ * parseModelSpec/formatModelForProvider FUNCTIONS and must NOT redefine this interface.
+ *
+ * @example
+ * ```ts
+ * // Qualified format
+ * const spec1: ModelSpec = {
+ *   provider: 'anthropic',
+ *   model: 'claude-sonnet-4-20250514',
+ *   raw: 'anthropic/claude-sonnet-4-20250514',
+ * };
+ *
+ * // Plain format (resolved against default provider)
+ * const spec2: ModelSpec = {
+ *   provider: 'anthropic',
+ *   model: 'claude-sonnet-4-20250514',
+ *   raw: 'claude-sonnet-4-20250514',
+ * };
+ * ```
+ */
+export interface ModelSpec {
+    /** LLM host — NOT the harness */
+    provider: ModelProviderId;
+    /** Model name (without provider prefix) */
+    model: string;
+    /** Original raw model string (preserves user input) */
+    raw: string;
+}
+/**
+ * The shared harness contract both `PiHarness` and `ClaudeCodeHarness` implement
+ * (PRD §7.3). Identical method surface to the legacy Provider interface; the
+ * `execute<T>()` return type matches the already-shipped AnthropicProvider.execute
+ * (src/harnesses/anthropic-provider.ts lines 338–344).
+ *
+ * Adapters: PiHarness wraps `createAgentSession()`; ClaudeCodeHarness (rename of
+ * AnthropicProvider) wraps the Claude Code SDK. New harnesses implement this and
+ * register with HarnessRegistry (§7.6, owned by P1.M2).
+ *
+ * @example <caption>Basic harness shape</caption>
+ * ```ts
+ * const harness: Harness = {
+ *   readonly id: 'pi',
+ *   readonly capabilities: { mcp: true, skills: true, lsp: true, streaming: true, sessions: true, extendedThinking: false },
+ *   initialize: async (opts?) => { … },
+ *   terminate: async () => { … },
+ *   execute: async <T>(req, toolExec, hooks?) => { … },
+ *   registerMCPs: async (servers) => [],
+ *   loadSkills: async (skills) => {},
+ *   normalizeModel: (model) => ({ provider: 'anthropic', model, raw: model }),
+ *   supports: (cap) => cap === 'mcp',
+ *   requiresFeatures: (features) => features.every(f => f === 'mcp'),
+ * };
+ * ```
+ */
+export interface Harness {
+    /**
+     * Unique harness identifier (one of the supported HarnessId values)
+     *
+     * @readonly
+     *
+     * @example
+     * ```ts
+     * readonly id: HarnessId;  // 'pi' | 'claude-code'
+     * ```
+     */
+    readonly id: HarnessId;
+    /**
+     * Capability flags for feature detection
+     *
+     * @readonly
+     *
+     * @example
+     * ```ts
+     * readonly capabilities: HarnessCapabilities;
+     * // { mcp: true, skills: true, lsp: true, streaming: true, sessions: false, extendedThinking: false }
+     * ```
+     */
+    readonly capabilities: HarnessCapabilities;
+    /**
+     * Initialize the harness with optional configuration (SDK clients, connections).
+     *
+     * @param options - Optional harness-specific configuration
+     *
+     * @example
+     * ```ts
+     * await harness.initialize({ apiKey: 'sk-...', endpoint: 'https://...' });
+     * ```
+     */
+    initialize(options?: HarnessOptions): Promise<void>;
+    /**
+     * Terminate the harness and release resources.
+     *
+     * @example
+     * ```ts
+     * await harness.terminate();
+     * ```
+     */
+    terminate(): Promise<void>;
+    /**
+     * Execute a prompt request with a type-safe response (PRD §7.3).
+     *
+     * `toolExecutor` delegates tool calls back to Groundswell's MCPHandler — the harness
+     * only reports tool calls back, it never executes them itself (PRD §7.10 / §7.12).
+     *
+     * @typeParam T - The expected response data type (inferred from schema or explicit)
+     * @param request - The prompt request with options
+     * @param toolExecutor - Callback for executing tools (delegated to MCPHandler)
+     * @param hooks - Optional lifecycle hooks for events
+     * @returns `Promise<AgentResponse<T>>` for non-streaming, or an
+     *          `AsyncGenerator<StreamEvent, AgentResponse<T>, unknown>` when
+     *          `request.options.streaming === true`.
+     *
+     * @example <caption>Non-streaming execution</caption>
+     * ```ts
+     * const response = await harness.execute<{ answer: string }>(
+     *   { prompt: 'What is 2+2?', options: {} },
+     *   toolExecutor,
+     *   hooks,
+     * );
+     * if (response.status === 'success') {
+     *   console.log(response.data.answer);  // Type-safe access
+     * }
+     * ```
+     *
+     * @example <caption>Streaming execution</caption>
+     * ```ts
+     * const stream = await harness.execute(
+     *   { prompt: '...', options: { streaming: true } },
+     *   toolExecutor,
+     * );
+     * for await (const event of stream) {
+     *   // Handle StreamEvent items
+     * }
+     * ```
+     */
+    execute<T>(request: HarnessRequest, toolExecutor: (req: ToolExecutionRequest) => Promise<ToolExecutionResult>, hooks?: HarnessHookEvents): Promise<AgentResponse<T>> | AsyncGenerator<StreamEvent, AgentResponse<T>, unknown>;
+    /**
+     * Register MCP servers and return the discovered tools (PRD §7.10 / §7.12).
+     *
+     * @param servers - Array of MCP server configurations
+     * @returns Promise resolving to array of discovered Tool definitions
+     *
+     * @example
+     * ```ts
+     * const tools = await harness.registerMCPs([
+     *   { name: 'filesystem', transport: 'stdio', command: 'python', args: ['mcp_server.py'] },
+     * ]);
+     * console.log(`Registered ${tools.length} tools`);
+     * ```
+     */
+    registerMCPs(servers: MCPServer[]): Promise<Tool[]>;
+    /**
+     * Load skills into the harness (PRD §7.12).
+     *
+     * @param skills - Array of skill definitions to load
+     *
+     * @example
+     * ```ts
+     * await harness.loadSkills([
+     *   { name: 'web-search', path: '/skills/web-search' },
+     * ]);
+     * ```
+     */
+    loadSkills(skills: Skill[]): Promise<void>;
+    /**
+     * Parse a model string into a ModelSpec (PRD §7.8).
+     *
+     * @param model - Model string to parse
+     * @returns ModelSpec with provider, model, and raw string
+     *
+     * @example
+     * ```ts
+     * harness.normalizeModel('claude-sonnet-4')
+     * // Returns: { provider: 'anthropic', model: 'claude-sonnet-4', raw: 'claude-sonnet-4' }
+     *
+     * harness.normalizeModel('anthropic/claude-opus-4')
+     * // Returns: { provider: 'anthropic', model: 'claude-opus-4', raw: 'anthropic/claude-opus-4' }
+     * ```
+     */
+    normalizeModel(model: string): ModelSpec;
+    /**
+     * Check if a single capability is supported.
+     *
+     * @param capability - The capability to check (must be keyof HarnessCapabilities)
+     * @returns true if the capability is supported, false otherwise
+     *
+     * @example
+     * ```ts
+     * if (harness.supports('mcp')) {
+     *   await harness.registerMCPs(servers);
+     * }
+     * ```
+     */
+    supports(capability: keyof HarnessCapabilities): boolean;
+    /**
+     * Check if ALL listed capabilities are supported (empty array → true).
+     *
+     * @param features - Array of capability keys to check
+     * @returns true if all features are supported, false if any are unsupported
+     *
+     * @example
+     * ```ts
+     * if (harness.requiresFeatures(['mcp', 'streaming'])) {
+     *   // Enable advanced features requiring both MCP and streaming
+     * }
+     * ```
+     */
+    requiresFeatures(features: (keyof HarnessCapabilities)[]): boolean;
+}
+/**
+ * Global harness configuration (PRD §7.6).
+ *
+ * Configures the default harness, optional per-harness options, and the default LLM provider
+ * that resolve unqualified model strings (PRD §7.8). Set once at application startup via
+ * `configureHarnesses()` (owned by P1.M2.T2.S1) — it cascades to all agents unless explicitly
+ * overridden (PRD §7.7).
+ *
+ * The two default axes are INDEPENDENT:
+ *  - `defaultHarness`        — the agent RUNTIME ('pi' | 'claude-code').
+ *  - `defaultModelProvider`  — the LLM HOST / vendor (open `ModelProviderId` set).
+ *
+ * This is the v1.2 successor to the legacy `GlobalProviderConfig`: it adds the orthogonal
+ * `defaultModelProvider` field and re-keys `harnessDefaults` by `HarnessId` (the legacy
+ * `providerDefaults` was keyed by the conflated `ProviderId`).
+ *
+ * @example
+ * ```ts
+ * const config: GlobalHarnessConfig = {
+ *   defaultHarness: 'pi',                  // vendor-neutral default runtime
+ *   defaultModelProvider: 'anthropic',     // LLM host — independent of harness
+ *   harnessDefaults: {
+ *     'claude-code': { apiKey: process.env.ANTHROPIC_API_KEY },
+ *   },
+ * };
+ * ```
+ */
+export interface GlobalHarnessConfig {
+    /** Default agent runtime used when none is specified (PRD §7.6 / §7.7 cascade root). */
+    defaultHarness: HarnessId;
+    /** Optional per-harness default options, keyed by HarnessId (runtime axis). */
+    harnessDefaults?: Partial<Record<HarnessId, HarnessOptions>>;
+    /**
+     * Default LLM provider used to resolve unqualified (plain) model strings (PRD §7.8).
+     *
+     * Open `ModelProviderId` set — independent of `defaultHarness`. When a caller passes a
+     * plain model id like `'claude-sonnet-4-20250514'`, `parseModelSpec` resolves its
+     * `provider` against this value.
+     */
+    defaultModelProvider?: ModelProviderId;
+}
+/**
+ * Parse a model specification string into a {@link ModelSpec} (PRD §7.8).
+ *
+ * Accepts two formats:
+ *  - Qualified: `"anthropic/claude-sonnet-4-20250514"` → `{ provider: 'anthropic', model: 'claude-sonnet-4-20250514', raw: … }`
+ *  - Plain:     `"claude-sonnet-4-20250514"`           → resolved against `defaultProvider`.
+ *
+ * `provider` is the LLM host (`ModelProviderId`, open set) — NEVER the harness
+ * (PRD §7.8 critical rule). Harness-qualified strings (`pi/anthropic/...`) are
+ * invalid and rejected by the implementation (P1.M1.T2.S1).
+ *
+ * @param model - Model string (`"provider/model"` or plain model id).
+ * @param defaultProvider - Provider used when `model` is unqualified (open set;
+ *        implementation default is `'anthropic'`).
+ * @returns Parsed {@link ModelSpec} (provider, model, raw).
+ *
+ * @remarks TYPE-ONLY ambient declaration — see file-level block comment.
+ *          Runtime implementation: `src/utils/model-spec.ts` (P1.M1.T2.S1).
+ */
+export declare function parseModelSpec(model: string, defaultProvider?: ModelProviderId): ModelSpec;
+/**
+ * Format a {@link ModelSpec} for a specific target provider (PRD §7.8).
+ *
+ * Pass-through (returns `spec.model`) when `spec.provider === targetProvider`;
+ * otherwise the implementation throws a cross-translation error (MVP behavior —
+ * same-provider validation / API preparation is the primary use case).
+ *
+ * @param spec - {@link ModelSpec} from `parseModelSpec()` or `Harness.normalizeModel()`.
+ * @param targetProvider - The LLM host to format the model for (open `ModelProviderId` set).
+ * @returns Formatted model string (model name only, when providers match).
+ *
+ * @remarks TYPE-ONLY ambient declaration — see file-level block comment.
+ *          Runtime implementation: `src/utils/model-spec.ts` (P1.M1.T2.S1).
+ */
+export declare function formatModelForProvider(spec: ModelSpec, targetProvider: ModelProviderId): string;
+//# sourceMappingURL=harnesses.d.ts.map

package/dist/types/harnesses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harnesses.d.ts","sourceRoot":"","sources":["../../src/types/harnesses.ts"],"names":[],"mappings":"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"}

package/dist/types/harnesses.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=harnesses.js.map

package/dist/types/harnesses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"harnesses.js","sourceRoot":"","sources":["../../src/types/harnesses.ts"],"names":[],"mappings":""}

package/dist/types/index.d.ts

@@ -0,0 +1,23 @@
+export type { WorkflowStatus, WorkflowNode } from './workflow.js';
+export type { LogLevel, LogEntry } from './logging.js';
+export type { SerializedWorkflowState, StateFieldMetadata } from './snapshot.js';
+export type { WorkflowError } from './error.js';
+export type { WorkflowEvent } from './events.js';
+export type { WorkflowObserver } from './observer.js';
+export type { RestartAnalysis, ErrorCriterion } from './restart.js';
+export type { StepOptions, TaskOptions } from './decorators.js';
+export type { ErrorMergeStrategy } from './error-strategy.js';
+export type { Tool, ToolResult, MCPServer, Skill, HookHandler, PreToolUseContext, PostToolUseContext, SessionStartContext, SessionEndContext, AgentHooks, TokenUsage, } from './sdk-primitives.js';
+export type { Provider, ProviderId, ProviderCapabilities, ProviderOptions, ProviderExecutionOptions, ProviderRequest, ProviderHookEvents, ToolExecutionRequest, ToolExecutionResult, ToolExecutor, ProviderResult, ProviderResponseStatus, ProviderErrorDetails, ProviderResponseMetadata, GlobalProviderConfig, SessionState, } from './providers.js';
+export type { Harness, HarnessId, ModelProviderId, HarnessCapabilities, HarnessOptions, HarnessRequest, HarnessHookEvents, GlobalHarnessConfig, ModelSpec, } from './harnesses.js';
+export { ClaudeCodeHarness, AnthropicProvider } from '../harnesses/claude-code-harness.js';
+export type { AgentConfig, PromptOverrides, AgentResponseStatus, AgentResponse, AgentErrorDetails, AgentResponseMetadata, SuccessResponse, ErrorResponse, PartialResponse, } from './agent.js';
+export { AGENT_ERROR_CODES, createSuccessResponse, createErrorResponse, createPartialResponse, isSuccess, isError, isPartial, } from './agent.js';
+export { AgentResponseStatusSchema, AgentErrorDetailsSchema, AgentResponseMetadataSchema, AgentResponseSchema, } from './agent.js';
+export type { PromptConfig } from './prompt.js';
+export type { WorkflowContext, WorkflowConfig, WorkflowResult, EventTreeHandle, EventNode, EventMetrics, AgentLike, PromptLike, } from './workflow-context.js';
+export type { ReflectionAPI, ReflectionConfig, ReflectionContext, ReflectionResult, ReflectionEntry, } from './reflection.js';
+export { DEFAULT_REFLECTION_CONFIG, createReflectionConfig, } from './reflection.js';
+export type { StreamEvent, AsyncStream, } from './streaming.js';
+export { isTextDeltaEvent, isToolCallEvent, isErrorEvent, } from './streaming.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClE,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACvD,YAAY,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACjF,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAGtD,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEpE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAChE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG9D,YAAY,EACV,IAAI,EACJ,UAAU,EACV,SAAS,EACT,KAAK,EACL,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,UAAU,EACV,UAAU,GACX,MAAM,qBAAqB,CAAC;AAG7B,YAAY,EACV,QAAQ,EACR,UAAU,EACV,oBAAoB,EACpB,eAAe,EACf,wBAAwB,EACxB,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACZ,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,wBAAwB,EACxB,oBAAoB,EACpB,YAAY,GACb,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EACV,OAAO,EACP,SAAS,EACT,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,mBAAmB,EACnB,SAAS,GACV,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAG3F,YAAY,EACV,WAAW,EACX,eAAe,EACf,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,EACf,aAAa,EACb,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,SAAS,EACT,OAAO,EACP,SAAS,GACV,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,EAC3B,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAGpB,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD,YAAY,EACV,eAAe,EACf,cAAc,EACd,cAAc,EACd,eAAe,EACf,SAAS,EACT,YAAY,EACZ,SAAS,EACT,UAAU,GACX,MAAM,uBAAuB,CAAC;AAG/B,YAAY,EACV,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,GAChB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,yBAAyB,EACzB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EACV,WAAW,EACX,WAAW,GACZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,YAAY,GACb,MAAM,gBAAgB,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,8 @@
+// Provider classes
+export { ClaudeCodeHarness, AnthropicProvider } from '../harnesses/claude-code-harness.js';
+export { AGENT_ERROR_CODES, createSuccessResponse, createErrorResponse, createPartialResponse, isSuccess, isError, isPartial, } from './agent.js';
+// Zod schemas for AgentResponse validation
+export { AgentResponseStatusSchema, AgentErrorDetailsSchema, AgentResponseMetadataSchema, AgentResponseSchema, } from './agent.js';
+export { DEFAULT_REFLECTION_CONFIG, createReflectionConfig, } from './reflection.js';
+export { isTextDeltaEvent, isToolCallEvent, isErrorEvent, } from './streaming.js';
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AA8DA,mBAAmB;AACnB,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAc3F,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,SAAS,EACT,OAAO,EACP,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,2CAA2C;AAC3C,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,EAC3B,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAyBpB,OAAO,EACL,yBAAyB,EACzB,sBAAsB,GACvB,MAAM,iBAAiB,CAAC;AAOzB,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,YAAY,GACb,MAAM,gBAAgB,CAAC"}

package/dist/types/logging.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Log severity levels
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * A single log entry in the workflow
+ */
+export interface LogEntry {
+    /** Unique identifier for this log entry */
+    id: string;
+    /** ID of the workflow that created this log */
+    workflowId: string;
+    /** Unix timestamp in milliseconds */
+    timestamp: number;
+    /** Severity level */
+    level: LogLevel;
+    /** Log message */
+    message: string;
+    /** Optional structured data */
+    data?: unknown;
+    /** ID of parent log entry (for hierarchical logging) */
+    parentLogId?: string;
+}
+//# sourceMappingURL=logging.d.ts.map

package/dist/types/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../src/types/logging.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,2CAA2C;IAC3C,EAAE,EAAE,MAAM,CAAC;IACX,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB;IACrB,KAAK,EAAE,QAAQ,CAAC;IAChB,kBAAkB;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/dist/types/logging.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logging.js.map

package/dist/types/logging.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.js","sourceRoot":"","sources":["../../src/types/logging.ts"],"names":[],"mappings":""}

package/dist/types/observer.d.ts

@@ -0,0 +1,18 @@
+import type { LogEntry } from './logging.js';
+import type { WorkflowEvent } from './events.js';
+import type { WorkflowNode } from './workflow.js';
+/**
+ * Observer interface for subscribing to workflow events
+ * Observers attach to the root workflow and receive all events
+ */
+export interface WorkflowObserver {
+    /** Called when a log entry is created */
+    onLog(entry: LogEntry): void;
+    /** Called when any workflow event occurs */
+    onEvent(event: WorkflowEvent): void;
+    /** Called when a node's state is updated */
+    onStateUpdated(node: WorkflowNode): void;
+    /** Called when the tree structure changes */
+    onTreeChanged(root: WorkflowNode): void;
+}
+//# sourceMappingURL=observer.d.ts.map

package/dist/types/observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer.d.ts","sourceRoot":"","sources":["../../src/types/observer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,yCAAyC;IACzC,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC7B,4CAA4C;IAC5C,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;IACpC,4CAA4C;IAC5C,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IACzC,6CAA6C;IAC7C,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;CACzC"}

package/dist/types/observer.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=observer.js.map

package/dist/types/observer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer.js","sourceRoot":"","sources":["../../src/types/observer.ts"],"names":[],"mappings":""}

package/dist/types/prompt.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Prompt configuration types
+ * Prompts are immutable definitions of what to send to an agent
+ */
+import type { z } from 'zod';
+import type { Tool, MCPServer, Skill, AgentHooks } from './sdk-primitives.js';
+/**
+ * Configuration for creating a Prompt instance
+ * @template T The expected response type (inferred from responseFormat)
+ */
+export interface PromptConfig<T> {
+    /** User message content */
+    user: string;
+    /** Structured data to inject into the prompt */
+    data?: Record<string, unknown>;
+    /** Zod schema defining the expected response format */
+    responseFormat: z.ZodType<T>;
+    /** Override system prompt (takes precedence over agent config) */
+    system?: string;
+    /** Override tools (takes precedence over agent config) */
+    tools?: Tool[];
+    /** Override MCPs (takes precedence over agent config) */
+    mcps?: MCPServer[];
+    /** Override skills (takes precedence over agent config) */
+    skills?: Skill[];
+    /** Override hooks (takes precedence over agent config) */
+    hooks?: AgentHooks;
+    /** Enable reflection specifically for this prompt */
+    enableReflection?: boolean;
+}
+//# sourceMappingURL=prompt.d.ts.map

package/dist/types/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/types/prompt.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE9E;;;GAGG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IAEb,gDAAgD;IAChD,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE/B,uDAAuD;IACvD,cAAc,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAE7B,kEAAkE;IAClE,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IAEf,yDAAyD;IACzD,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;IAEnB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;IAEjB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,UAAU,CAAC;IAEnB,qDAAqD;IACrD,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B"}

package/dist/types/prompt.js

@@ -0,0 +1,6 @@
+/**
+ * Prompt configuration types
+ * Prompts are immutable definitions of what to send to an agent
+ */
+export {};
+//# sourceMappingURL=prompt.js.map

package/dist/types/prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.js","sourceRoot":"","sources":["../../src/types/prompt.ts"],"names":[],"mappings":"AAAA;;;GAGG"}