@agtlantis/core 0.5.0 → 0.5.1

package/dist/observability/index.d.ts

@@ -0,0 +1,4 @@
+export type { EventMetrics, LanguageModelUsage, ExecutionMetadata } from './types.js';
+export type { Logger, LogLevel, LLMCallLogType, LLMCallStartEvent, LLMCallEndEvent, ExecutionStartEvent, ExecutionEmitEvent, ExecutionDoneEvent, ExecutionErrorEvent, } from './logger.js';
+export { noopLogger, createLogger } from './logger.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/observability/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEtF,YAAY,EACV,MAAM,EACN,QAAQ,EACR,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/observability/index.js

@@ -0,0 +1,2 @@
+export { noopLogger, createLogger } from './logger.js';
+//# sourceMappingURL=index.js.map

package/dist/observability/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/observability/index.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/observability/logger.d.ts

@@ -0,0 +1,161 @@
+import type { LanguageModelUsage } from 'ai';
+import type { SessionSummary } from '../session/types.js';
+/**
+ * Logger interface for observability.
+ * All methods are optional - implement only the events you care about.
+ *
+ * @example
+ * ```typescript
+ * const myLogger: Logger = {
+ *   onLLMCallEnd(event) {
+ *     console.log(`${event.modelId}: ${event.response.duration}ms`);
+ *   },
+ *   onExecutionDone(event) {
+ *     console.log('Total duration:', event.duration);
+ *   },
+ * };
+ * ```
+ */
+export interface Logger {
+    onLLMCallStart?(event: LLMCallStartEvent): void;
+    onLLMCallEnd?(event: LLMCallEndEvent): void;
+    onExecutionStart?(event: ExecutionStartEvent): void;
+    onExecutionEmit?<TEvent>(event: ExecutionEmitEvent<TEvent>): void;
+    onExecutionDone?<TResult>(event: ExecutionDoneEvent<TResult>): void;
+    onExecutionError?<TResult>(event: ExecutionErrorEvent<TResult>): void;
+    log?(level: LogLevel, message: string, data?: Record<string, unknown>): void;
+}
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export type LLMCallLogType = 'generateText' | 'streamText';
+/**
+ * Event emitted when an LLM call starts.
+ *
+ * @example
+ * ```typescript
+ * logger.onLLMCallStart?.({
+ *   type: 'llm_call_start',
+ *   callType: 'generateText',
+ *   modelId: 'gemini-2.5-flash',
+ *   timestamp: Date.now(),
+ *   request: { params: { prompt: 'Hello' } },
+ * });
+ * ```
+ */
+export interface LLMCallStartEvent {
+    type: 'llm_call_start';
+    callType: LLMCallLogType;
+    modelId: string;
+    timestamp: number;
+    request: {
+        params: Record<string, unknown>;
+    };
+}
+/**
+ * Event emitted when an LLM call ends (success or error).
+ *
+ * @example Success case:
+ * ```typescript
+ * logger.onLLMCallEnd?.({
+ *   type: 'llm_call_end',
+ *   callType: 'generateText',
+ *   modelId: 'gemini-2.5-flash',
+ *   timestamp: Date.now(),
+ *   response: {
+ *     duration: 1500,
+ *     usage: { inputTokens: 100, outputTokens: 50, totalTokens: 150 },
+ *     raw: result,
+ *   },
+ * });
+ * ```
+ *
+ * @example Error case:
+ * ```typescript
+ * logger.onLLMCallEnd?.({
+ *   type: 'llm_call_end',
+ *   callType: 'streamText',
+ *   modelId: 'gpt-4o',
+ *   timestamp: Date.now(),
+ *   response: {
+ *     duration: 500,
+ *     error: new Error('Rate limit exceeded'),
+ *     raw: null,
+ *   },
+ * });
+ * ```
+ */
+export interface LLMCallEndEvent {
+    type: 'llm_call_end';
+    callType: LLMCallLogType;
+    modelId: string;
+    timestamp: number;
+    response: {
+        duration: number;
+        usage?: LanguageModelUsage;
+        raw: unknown;
+        error?: Error;
+    };
+}
+export interface ExecutionStartEvent {
+    type: 'execution_start';
+    timestamp: number;
+}
+/**
+ * Event emitted for each intermediate event during execution.
+ * @typeParam TEvent - The type of the emitted event (includes metrics)
+ */
+export interface ExecutionEmitEvent<TEvent = unknown> {
+    type: 'execution_emit';
+    event: TEvent;
+}
+/**
+ * Event emitted when execution completes successfully.
+ * @typeParam TResult - The type of the execution result
+ */
+export interface ExecutionDoneEvent<TResult = unknown> {
+    type: 'execution_done';
+    timestamp: number;
+    duration: number;
+    data: TResult;
+    summary: SessionSummary;
+}
+/**
+ * Event emitted when execution fails with an error.
+ * @typeParam TResult - The type of partial result data (if available)
+ */
+export interface ExecutionErrorEvent<TResult = unknown> {
+    type: 'execution_error';
+    timestamp: number;
+    duration: number;
+    error: Error;
+    data?: TResult;
+    summary?: SessionSummary;
+}
+/**
+ * No-op logger (default when no logger provided).
+ *
+ * @example
+ * ```typescript
+ * const provider = createGoogleProvider({
+ *   apiKey: 'xxx',
+ *   logger: noopLogger,
+ * });
+ * ```
+ */
+export declare const noopLogger: Logger;
+/**
+ * Helper to create a logger with only the handlers you need.
+ *
+ * @example
+ * ```typescript
+ * const metricsLogger = createLogger({
+ *   onLLMCallEnd(event) {
+ *     metrics.recordLatency(event.response.duration);
+ *   },
+ *   onExecutionDone(event) {
+ *     metrics.recordTokens(event.summary.totalLLMUsage.totalTokens);
+ *   },
+ * });
+ * ```
+ */
+export declare function createLogger(handlers: Partial<Logger>): Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/observability/logger.d.ts.map

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

package/dist/observability/logger.js

@@ -0,0 +1,31 @@
+/**
+ * No-op logger (default when no logger provided).
+ *
+ * @example
+ * ```typescript
+ * const provider = createGoogleProvider({
+ *   apiKey: 'xxx',
+ *   logger: noopLogger,
+ * });
+ * ```
+ */
+export const noopLogger = {};
+/**
+ * Helper to create a logger with only the handlers you need.
+ *
+ * @example
+ * ```typescript
+ * const metricsLogger = createLogger({
+ *   onLLMCallEnd(event) {
+ *     metrics.recordLatency(event.response.duration);
+ *   },
+ *   onExecutionDone(event) {
+ *     metrics.recordTokens(event.summary.totalLLMUsage.totalTokens);
+ *   },
+ * });
+ * ```
+ */
+export function createLogger(handlers) {
+    return handlers;
+}
+//# sourceMappingURL=logger.js.map

package/dist/observability/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/observability/logger.ts"],"names":[],"mappings":"AA8IA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,UAAU,GAAW,EAAE,CAAC;AAErC;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,YAAY,CAAC,QAAyB,EAAU;IAC9D,OAAO,QAAQ,CAAC;AAAA,CACjB"}

package/dist/observability/types.d.ts

@@ -0,0 +1,46 @@
+import type { LanguageModelUsage } from 'ai';
+/**
+ * Timing metrics attached to each streaming event.
+ * Enables performance monitoring and latency debugging.
+ *
+ * @example
+ * ```typescript
+ * const event = {
+ *   type: 'progress',
+ *   message: 'Processing...',
+ *   metrics: {
+ *     timestamp: Date.now(),
+ *     elapsedMs: 150,
+ *     deltaMs: 50,
+ *   },
+ * };
+ * ```
+ */
+export interface EventMetrics {
+    timestamp: number;
+    elapsedMs: number;
+    deltaMs: number;
+}
+export type { LanguageModelUsage } from 'ai';
+/**
+ * Metadata collected during agent execution.
+ * Available after execution completes via `getSummary()`.
+ *
+ * @example
+ * ```typescript
+ * const metadata: ExecutionMetadata = {
+ *   duration: 1250,
+ *   usage: {
+ *     inputTokens: 500,
+ *     outputTokens: 200,
+ *     totalTokens: 700,
+ *   },
+ * };
+ * ```
+ */
+export interface ExecutionMetadata {
+    duration: number;
+    languageModelUsage?: LanguageModelUsage;
+    [key: string]: unknown;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/observability/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,IAAI,CAAC;AAE7C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,YAAY;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,YAAY,EAAE,kBAAkB,EAAE,MAAM,IAAI,CAAC;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,iBAAiB;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B"}

package/dist/observability/types.js

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

package/dist/observability/types.js.map

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

package/dist/patterns/index.d.ts

@@ -0,0 +1,2 @@
+export * from './progressive/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/patterns/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/dist/patterns/index.js

@@ -0,0 +1,2 @@
+export * from './progressive/index.js';
+//# sourceMappingURL=index.js.map

package/dist/patterns/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/patterns/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/dist/patterns/progressive/index.d.ts

@@ -0,0 +1,2 @@
+export { defineProgressivePattern, ProgressivePattern, TOOL_CALLING_PROTOCOL, type ProgressiveStreamOptions, type ProgressEvent, type CompleteEvent, } from './progressive-pattern.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/patterns/progressive/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/patterns/progressive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAClB,qBAAqB,EACrB,KAAK,wBAAwB,EAC7B,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,0BAA0B,CAAC"}

package/dist/patterns/progressive/index.js

@@ -0,0 +1,2 @@
+export { defineProgressivePattern, ProgressivePattern, TOOL_CALLING_PROTOCOL, } from './progressive-pattern.js';
+//# sourceMappingURL=index.js.map

package/dist/patterns/progressive/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/patterns/progressive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAClB,qBAAqB,GAItB,MAAM,0BAA0B,CAAC"}

package/dist/patterns/progressive/progressive-pattern.d.ts

@@ -0,0 +1,174 @@
+import { type StopCondition, type ToolSet } from 'ai';
+import { z } from 'zod';
+import type { ErrorEvent, SessionEvent } from '../../execution/types.js';
+import type { BaseProvider } from '../../provider/base-provider.js';
+import type { StreamingSession } from '../../session/streaming-session.js';
+import type { StreamTextParams } from '../../session/types.js';
+export type ProgressiveStreamOptions<TUserTools extends ToolSet = {}> = Omit<StreamTextParams<TUserTools>, 'tools' | 'toolChoice' | 'stopWhen'> & {
+    tools?: TUserTools;
+    /**
+     * Additional stop conditions. Will be combined with the default
+     * `hasToolCall('submitResult')`.
+     */
+    stopWhen?: StopCondition<ToolSet> | StopCondition<ToolSet>[];
+    /**
+     * Custom protocol instructions appended to the system prompt.
+     * If not provided, uses the default TOOL_CALLING_PROTOCOL.
+     */
+    protocol?: string;
+};
+/**
+ * Progress event - pure domain event without metrics.
+ * Framework automatically wraps with SessionEvent at runtime.
+ */
+export interface ProgressEvent<TProgress> {
+    type: 'progress';
+    data: TProgress;
+}
+/**
+ * Complete event - pure domain event without metrics.
+ * Framework automatically wraps with SessionEvent at runtime.
+ */
+export interface CompleteEvent<TResult> {
+    type: 'complete';
+    data: TResult;
+    summary: unknown;
+}
+export declare const TOOL_CALLING_PROTOCOL = "## CRITICAL INSTRUCTION - READ CAREFULLY\n\nYou have 2 tools available:\n1. reportProgress - [OPTIONAL] Show intermediate work (multiple times)\n2. submitResult - [REQUIRED] Submit your final answer\n\n\u26A0\uFE0F IMPORTANT RULES:\n- You may call reportProgress 0-3 times to show progress\n- You MUST call submitResult exactly once to complete the task\n- After calling reportProgress, you MUST call submitResult in your NEXT response\n- If you call reportProgress more than 3 times without submitResult, the task FAILS\n- The task is NOT complete until submitResult is called\n\nCORRECT SEQUENCE:\n1. [Optional] reportProgress\n2. [Required] submitResult (exactly once)\n\n\u274C WRONG: reportProgress \u2192 reportProgress \u2192 reportProgress \u2192 reportProgress (no submitResult = FAIL)\n\u2705 CORRECT: reportProgress \u2192 submitResult (SUCCESS)";
+/**
+ * Creates a progressive pattern for streaming LLM responses with intermediate progress updates.
+ *
+ * The pattern automatically:
+ * - Injects `reportProgress` and `submitResult` tools
+ * - Stops when `submitResult` is called (via `hasToolCall('submitResult')`)
+ * - Appends protocol instructions to the system prompt
+ *
+ * @example Basic usage
+ * ```typescript
+ * const pattern = defineProgressivePattern({
+ *   progressSchema: z.object({ stage: z.string(), message: z.string() }),
+ *   resultSchema: z.object({ summary: z.string(), score: z.number() }),
+ * });
+ *
+ * for await (const event of pattern.run(provider, {
+ *   system: 'You are an analyzer.',
+ *   prompt: 'Analyze this...',
+ * })) {
+ *   console.log(event.type, event.data);
+ * }
+ * ```
+ *
+ * @example With custom stopWhen (add step limit)
+ * ```typescript
+ * import { stepCountIs } from 'ai';
+ *
+ * for await (const event of pattern.run(provider, {
+ *   prompt: 'Analyze...',
+ *   stopWhen: stepCountIs(10), // Stop at submitResult OR after 10 steps
+ * })) { ... }
+ * ```
+ *
+ * @example With custom protocol
+ * ```typescript
+ * for await (const event of pattern.run(provider, {
+ *   prompt: 'Analyze...',
+ *   protocol: 'Call reportProgress for each step, then submitResult.',
+ * })) { ... }
+ * ```
+ *
+ * @example Composable (within a session)
+ * ```typescript
+ * provider.streamingExecution(async function*(session) {
+ *   yield* pattern.runInSession(session, {
+ *     system: 'You are an analyzer.',
+ *     messages: [...],
+ *   });
+ * });
+ * ```
+ */
+export declare function defineProgressivePattern<TProgressSchema extends z.ZodType, TResultSchema extends z.ZodType>(config: {
+    progressSchema: TProgressSchema;
+    resultSchema: TResultSchema;
+}): ProgressivePattern<TProgressSchema, TResultSchema, z.TypeOf<TProgressSchema>, z.TypeOf<TResultSchema>, {
+    type: string;
+}>;
+export declare class ProgressivePattern<TProgressSchema extends z.ZodType, TResultSchema extends z.ZodType, TProgress = z.infer<TProgressSchema>, TResult = z.infer<TResultSchema>, TEvent extends {
+    type: string;
+} = {
+    type: string;
+}> {
+    readonly progressSchema: TProgressSchema;
+    readonly resultSchema: TResultSchema;
+    constructor(progressSchema: TProgressSchema, resultSchema: TResultSchema);
+    private lastParseError;
+    /**
+     * Runs the pattern within an existing session. Use this for composing
+     * multiple patterns or when you need fine-grained control over the session.
+     *
+     * @param session - The streaming session to run within
+     * @param options - Stream options including:
+     *   - `stopWhen` - Additional stop conditions (combined with default `hasToolCall('submitResult')`)
+     *   - `protocol` - Custom protocol instructions (replaces default `TOOL_CALLING_PROTOCOL`)
+     *   - All other `streamText` options except `tools`, `toolChoice`, `stopWhen`
+     *
+     * @example Basic usage
+     * ```typescript
+     * provider.streamingExecution(async function*(session) {
+     *   yield* pattern.runInSession(session, {
+     *     system: 'You are an analyzer.',
+     *     messages: [{ role: 'user', content: 'Analyze...' }],
+     *   });
+     * });
+     * ```
+     *
+     * @example With custom stopWhen
+     * ```typescript
+     * yield* pattern.runInSession(session, {
+     *   prompt: 'Analyze...',
+     *   stopWhen: stepCountIs(5), // Combined: submitResult OR 5 steps
+     * });
+     * ```
+     */
+    runInSession<TUserTools extends ToolSet = {}>(session: StreamingSession<TEvent>, options: ProgressiveStreamOptions<TUserTools>): AsyncGenerator<SessionEvent<TEvent>, SessionEvent<TEvent>, undefined>;
+    /**
+     * Standalone execution that creates a new session internally.
+     * Use this for simple, single-pattern executions.
+     *
+     * @param provider - The AI provider to use
+     * @param options - Stream options including:
+     *   - `stopWhen` - Additional stop conditions (combined with default `hasToolCall('submitResult')`)
+     *   - `protocol` - Custom protocol instructions (replaces default `TOOL_CALLING_PROTOCOL`)
+     *
+     * @example Basic usage
+     * ```typescript
+     * for await (const event of pattern.run(provider, {
+     *   system: 'You are an analyzer.',
+     *   prompt: 'Analyze this document...',
+     * })) {
+     *   if (event.type === 'progress') {
+     *     console.log('Progress:', event.data);
+     *   } else if (event.type === 'complete') {
+     *     console.log('Result:', event.data);
+     *   }
+     * }
+     * ```
+     *
+     * @example With step limit
+     * ```typescript
+     * import { stepCountIs } from 'ai';
+     *
+     * for await (const event of pattern.run(provider, {
+     *   prompt: 'Analyze...',
+     *   stopWhen: stepCountIs(10),
+     * })) { ... }
+     * ```
+     */
+    run<TUserTools extends ToolSet = {}>(provider: BaseProvider, options: ProgressiveStreamOptions<TUserTools>): AsyncIterable<SessionEvent<TEvent | ErrorEvent>>;
+    private createTools;
+    private parseJsonWrapper;
+    private parseProgressInput;
+    private parseResultInput;
+    private combineStopConditions;
+    private renderSystemPrompt;
+}
+//# sourceMappingURL=progressive-pattern.d.ts.map

package/dist/patterns/progressive/progressive-pattern.d.ts.map

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