@eggjs/agent-runtime 0.0.0 → 3.73.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from '@eggjs/tegg-types/agent-runtime';
+export * from './src/OSSObjectStorageClient';
+export * from './src/OSSAgentStore';
+export * from './src/AgentStoreUtils';
+export * from './src/MessageConverter';
+export * from './src/RunBuilder';
+export * from './src/SSEWriter';
+export * from './src/HttpSSEWriter';
+export { AgentRuntime, AGENT_RUNTIME } from './src/AgentRuntime';
+export type { AgentExecutor, AgentRuntimeOptions } from './src/AgentRuntime';

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_RUNTIME = exports.AgentRuntime = void 0;
+// Re-export types from @eggjs/tegg-types (backward compatible)
+__exportStar(require("@eggjs/tegg-types/agent-runtime"), exports);
+// Implementation code
+__exportStar(require("./src/OSSObjectStorageClient"), exports);
+__exportStar(require("./src/OSSAgentStore"), exports);
+__exportStar(require("./src/AgentStoreUtils"), exports);
+__exportStar(require("./src/MessageConverter"), exports);
+__exportStar(require("./src/RunBuilder"), exports);
+__exportStar(require("./src/SSEWriter"), exports);
+__exportStar(require("./src/HttpSSEWriter"), exports);
+var AgentRuntime_1 = require("./src/AgentRuntime");
+Object.defineProperty(exports, "AgentRuntime", { enumerable: true, get: function () { return AgentRuntime_1.AgentRuntime; } });
+Object.defineProperty(exports, "AGENT_RUNTIME", { enumerable: true, get: function () { return AgentRuntime_1.AGENT_RUNTIME; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtEQUErRDtBQUMvRCxrRUFBZ0Q7QUFDaEQsc0JBQXNCO0FBQ3RCLCtEQUE2QztBQUM3QyxzREFBb0M7QUFDcEMsd0RBQXNDO0FBQ3RDLHlEQUF1QztBQUN2QyxtREFBaUM7QUFDakMsa0RBQWdDO0FBQ2hDLHNEQUFvQztBQUNwQyxtREFBaUU7QUFBeEQsNEdBQUEsWUFBWSxPQUFBO0FBQUUsNkdBQUEsYUFBYSxPQUFBIn0=

package/dist/src/AgentRuntime.d.ts

@@ -0,0 +1,42 @@
+import type { CreateRunInput, ThreadObject, ThreadObjectWithMessages, RunObject, AgentStreamMessage, AgentStore } from '@eggjs/tegg-types/agent-runtime';
+import type { EggLogger } from 'egg-logger';
+import type { SSEWriter } from './SSEWriter';
+export declare const AGENT_RUNTIME: unique symbol;
+/**
+ * The executor interface — only requires execRun so the runtime can delegate
+ * execution back through the controller's prototype chain (AOP/mock friendly).
+ */
+export interface AgentExecutor {
+    execRun(input: CreateRunInput, signal?: AbortSignal): AsyncGenerator<AgentStreamMessage>;
+}
+export interface AgentRuntimeOptions {
+    executor: AgentExecutor;
+    store: AgentStore;
+    logger: EggLogger;
+}
+export declare class AgentRuntime {
+    private static readonly TERMINAL_RUN_STATUSES;
+    private store;
+    private runningTasks;
+    private executor;
+    private logger;
+    constructor(options: AgentRuntimeOptions);
+    createThread(): Promise<ThreadObject>;
+    getThread(threadId: string): Promise<ThreadObjectWithMessages>;
+    private ensureThread;
+    syncRun(input: CreateRunInput, signal?: AbortSignal): Promise<RunObject>;
+    asyncRun(input: CreateRunInput): Promise<RunObject>;
+    streamRun(input: CreateRunInput, writer: SSEWriter): Promise<void>;
+    /**
+     * Consume the execRun async generator, emitting SSE message.delta events
+     * for each chunk and accumulating content blocks and token usage.
+     */
+    private consumeStreamMessages;
+    getRun(runId: string): Promise<RunObject>;
+    cancelRun(runId: string): Promise<RunObject>;
+    /** Wait for all in-flight background tasks to complete naturally (without aborting). */
+    waitForPendingTasks(): Promise<void>;
+    destroy(): Promise<void>;
+    /** Factory method — avoids the spread-arg type issue with dynamic delegation. */
+    static create(options: AgentRuntimeOptions): AgentRuntime;
+}

package/dist/src/AgentRuntime.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRuntime = exports.AGENT_RUNTIME = void 0;
+const agent_runtime_1 = require("@eggjs/tegg-types/agent-runtime");
+const AgentStoreUtils_1 = require("./AgentStoreUtils");
+const MessageConverter_1 = require("./MessageConverter");
+const RunBuilder_1 = require("./RunBuilder");
+exports.AGENT_RUNTIME = Symbol('agentRuntime');
+class AgentRuntime {
+    constructor(options) {
+        this.executor = options.executor;
+        this.store = options.store;
+        if (!options.logger) {
+            throw new Error('AgentRuntimeOptions.logger is required');
+        }
+        this.logger = options.logger;
+        this.runningTasks = new Map();
+    }
+    async createThread() {
+        var _a;
+        const thread = await this.store.createThread();
+        return {
+            id: thread.id,
+            object: agent_runtime_1.AgentObjectType.Thread,
+            createdAt: thread.createdAt,
+            metadata: (_a = thread.metadata) !== null && _a !== void 0 ? _a : {},
+        };
+    }
+    async getThread(threadId) {
+        var _a;
+        const thread = await this.store.getThread(threadId);
+        return {
+            id: thread.id,
+            object: agent_runtime_1.AgentObjectType.Thread,
+            createdAt: thread.createdAt,
+            metadata: (_a = thread.metadata) !== null && _a !== void 0 ? _a : {},
+            messages: thread.messages,
+        };
+    }
+    async ensureThread(input) {
+        if (input.threadId) {
+            return { threadId: input.threadId, input };
+        }
+        const thread = await this.store.createThread();
+        return { threadId: thread.id, input: { ...input, threadId: thread.id } };
+    }
+    async syncRun(input, signal) {
+        const { threadId, input: resolvedInput } = await this.ensureThread(input);
+        input = resolvedInput;
+        const run = await this.store.createRun(input.input.messages, threadId, input.config, input.metadata);
+        const rb = RunBuilder_1.RunBuilder.create(run, threadId);
+        // Bridge external signal to an internal AbortController so cancelRun can abort syncRun
+        const abortController = new AbortController();
+        if (signal) {
+            if (signal.aborted) {
+                abortController.abort();
+            }
+            else {
+                signal.addEventListener('abort', () => abortController.abort(), { once: true });
+            }
+        }
+        // Register in runningTasks so cancelRun can find and await this run.
+        // Use a real pending promise (not Promise.resolve()) so cancelRun's
+        // `await task.promise` blocks until syncRun's try/finally completes.
+        let resolveTask;
+        const taskPromise = new Promise(r => {
+            resolveTask = r;
+        });
+        this.runningTasks.set(run.id, { promise: taskPromise, abortController });
+        try {
+            await this.store.updateRun(run.id, rb.start());
+            const streamMessages = [];
+            for await (const msg of this.executor.execRun(input, abortController.signal)) {
+                if (abortController.signal.aborted) {
+                    // Run was cancelled externally — re-read store for the latest state
+                    const latest = await this.store.getRun(run.id);
+                    return RunBuilder_1.RunBuilder.fromRecord(latest).snapshot();
+                }
+                streamMessages.push(msg);
+            }
+            const { output, usage } = MessageConverter_1.MessageConverter.extractFromStreamMessages(streamMessages, run.id);
+            // Append messages first so that if updateRun fails the run stays in_progress
+            // and can be retried, rather than showing completed with missing thread history.
+            // TODO(atomicity): for full consistency, add an aggregate store method
+            // (e.g. completeRunWithMessages) that wraps both writes in a single transaction.
+            await this.store.appendMessages(threadId, [
+                ...MessageConverter_1.MessageConverter.toInputMessageObjects(input.input.messages, threadId),
+                ...output,
+            ]);
+            await this.store.updateRun(run.id, rb.complete(output, usage));
+            return rb.snapshot();
+        }
+        catch (err) {
+            if (abortController.signal.aborted) {
+                // Cancelled — re-read store for the latest state
+                const latest = await this.store.getRun(run.id);
+                return RunBuilder_1.RunBuilder.fromRecord(latest).snapshot();
+            }
+            try {
+                await this.store.updateRun(run.id, rb.fail(err));
+            }
+            catch (storeErr) {
+                this.logger.error('[AgentRuntime] failed to update run status after syncRun error:', storeErr);
+            }
+            throw err;
+        }
+        finally {
+            resolveTask();
+            this.runningTasks.delete(run.id);
+        }
+    }
+    async asyncRun(input) {
+        const { threadId, input: resolvedInput } = await this.ensureThread(input);
+        input = resolvedInput;
+        const run = await this.store.createRun(input.input.messages, threadId, input.config, input.metadata);
+        const rb = RunBuilder_1.RunBuilder.create(run, threadId);
+        const abortController = new AbortController();
+        // Capture queued snapshot before background task mutates state
+        const queuedSnapshot = rb.snapshot();
+        // Register in runningTasks before the IIFE starts executing to avoid a race
+        // where the IIFE's finally block deletes the entry before it is set.
+        let resolveTask;
+        const taskPromise = new Promise(r => {
+            resolveTask = r;
+        });
+        this.runningTasks.set(run.id, { promise: taskPromise, abortController });
+        (async () => {
+            try {
+                await this.store.updateRun(run.id, rb.start());
+                const streamMessages = [];
+                for await (const msg of this.executor.execRun(input, abortController.signal)) {
+                    if (abortController.signal.aborted)
+                        return;
+                    streamMessages.push(msg);
+                }
+                // Check if another worker has cancelled this run before writing final state
+                const currentRun = await this.store.getRun(run.id);
+                if (currentRun.status === agent_runtime_1.RunStatus.Cancelling || currentRun.status === agent_runtime_1.RunStatus.Cancelled) {
+                    return;
+                }
+                const { output, usage } = MessageConverter_1.MessageConverter.extractFromStreamMessages(streamMessages, run.id);
+                // Append messages before marking run as completed — see syncRun comment.
+                // TODO(atomicity): add aggregate store method for full transactional guarantee.
+                await this.store.appendMessages(threadId, [
+                    ...MessageConverter_1.MessageConverter.toInputMessageObjects(input.input.messages, threadId),
+                    ...output,
+                ]);
+                await this.store.updateRun(run.id, rb.complete(output, usage));
+            }
+            catch (err) {
+                if (!abortController.signal.aborted) {
+                    // Check store before writing failed state — another worker may have cancelled
+                    try {
+                        const currentRun = await this.store.getRun(run.id);
+                        if (currentRun.status !== agent_runtime_1.RunStatus.Cancelling && currentRun.status !== agent_runtime_1.RunStatus.Cancelled) {
+                            await this.store.updateRun(run.id, rb.fail(err));
+                        }
+                    }
+                    catch (storeErr) {
+                        // TODO: need a background expiry mechanism to clean up runs stuck in non-terminal states
+                        // (e.g. in_progress or cancelling) when store writes fail persistently.
+                        this.logger.error('[AgentRuntime] failed to update run status after error:', storeErr);
+                    }
+                }
+                else {
+                    this.logger.error('[AgentRuntime] execRun error during abort:', err);
+                }
+            }
+            finally {
+                resolveTask();
+                this.runningTasks.delete(run.id);
+            }
+        })();
+        return queuedSnapshot;
+    }
+    async streamRun(input, writer) {
+        // Abort execRun generator when client disconnects
+        const abortController = new AbortController();
+        writer.onClose(() => abortController.abort());
+        const { threadId, input: resolvedInput } = await this.ensureThread(input);
+        input = resolvedInput;
+        const run = await this.store.createRun(input.input.messages, threadId, input.config, input.metadata);
+        const rb = RunBuilder_1.RunBuilder.create(run, threadId);
+        // Register in runningTasks so cancelRun/destroy can manage streaming runs.
+        let resolveTask;
+        const taskPromise = new Promise(r => {
+            resolveTask = r;
+        });
+        this.runningTasks.set(run.id, { promise: taskPromise, abortController });
+        // event: thread.run.created
+        writer.writeEvent(agent_runtime_1.AgentSSEEvent.ThreadRunCreated, rb.snapshot());
+        // event: thread.run.in_progress
+        await this.store.updateRun(run.id, rb.start());
+        writer.writeEvent(agent_runtime_1.AgentSSEEvent.ThreadRunInProgress, rb.snapshot());
+        const msgId = (0, AgentStoreUtils_1.newMsgId)();
+        // event: thread.message.created
+        const msgObj = MessageConverter_1.MessageConverter.createStreamMessage(msgId, run.id);
+        writer.writeEvent(agent_runtime_1.AgentSSEEvent.ThreadMessageCreated, msgObj);
+        try {
+            const { content, usage, aborted } = await this.consumeStreamMessages(input, abortController.signal, writer, msgId);
+            if (aborted) {
+                // Skip intermediate cancelling store write — no external observer between the
+                // two states since the SSE client has already disconnected.
+                rb.cancelling();
+                try {
+                    await this.store.updateRun(run.id, rb.cancel());
+                }
+                catch (storeErr) {
+                    this.logger.error('[AgentRuntime] failed to write cancelled status during stream abort:', storeErr);
+                }
+                if (!writer.closed) {
+                    writer.writeEvent(agent_runtime_1.AgentSSEEvent.ThreadRunCancelled, rb.snapshot());
+                }
+                return;
+            }
+            // event: thread.message.completed
+            const completedMsg = MessageConverter_1.MessageConverter.completeMessage(msgObj, content);
+            writer.writeEvent(agent_runtime_1.AgentSSEEvent.ThreadMessageCompleted, completedMsg);
+            // Persist and emit completion — append messages before marking run as completed
+            // so a failure leaves the run in_progress (retryable) instead of completed-but-incomplete.
+            // TODO(atomicity): add aggregate store method for full transactional guarantee.
+            const output = content.length > 0 ? [completedMsg] : [];
+            await this.store.appendMessages(threadId, [
+                ...MessageConverter_1.MessageConverter.toInputMessageObjects(input.input.messages, threadId),
+                ...output,
+            ]);
+            await this.store.updateRun(run.id, rb.complete(output, usage));
+            // event: thread.run.completed
+            writer.writeEvent(agent_runtime_1.AgentSSEEvent.ThreadRunCompleted, rb.snapshot());
+        }
+        catch (err) {
+            if (abortController.signal.aborted) {
+                // Client disconnected or cancelRun fired — mark as cancelled, not failed
+                rb.cancelling();
+                try {
+                    await this.store.updateRun(run.id, rb.cancel());
+                }
+                catch (storeErr) {
+                    this.logger.error('[AgentRuntime] failed to write cancelled status during stream error:', storeErr);
+                }
+                if (!writer.closed) {
+                    writer.writeEvent(agent_runtime_1.AgentSSEEvent.ThreadRunCancelled, rb.snapshot());
+                }
+            }
+            else {
+                try {
+                    await this.store.updateRun(run.id, rb.fail(err));
+                }
+                catch (storeErr) {
+                    this.logger.error('[AgentRuntime] failed to update run status after error:', storeErr);
+                }
+                // event: thread.run.failed
+                if (!writer.closed) {
+                    writer.writeEvent(agent_runtime_1.AgentSSEEvent.ThreadRunFailed, rb.snapshot());
+                }
+            }
+        }
+        finally {
+            resolveTask();
+            this.runningTasks.delete(run.id);
+            // event: done
+            if (!writer.closed) {
+                writer.writeEvent(agent_runtime_1.AgentSSEEvent.Done, '[DONE]');
+                writer.end();
+            }
+        }
+    }
+    /**
+     * Consume the execRun async generator, emitting SSE message.delta events
+     * for each chunk and accumulating content blocks and token usage.
+     */
+    async consumeStreamMessages(input, signal, writer, msgId) {
+        var _a, _b;
+        const content = [];
+        let promptTokens = 0;
+        let completionTokens = 0;
+        let hasUsage = false;
+        for await (const msg of this.executor.execRun(input, signal)) {
+            if (signal.aborted) {
+                return { content, usage: undefined, aborted: true };
+            }
+            if (msg.message) {
+                const contentBlocks = MessageConverter_1.MessageConverter.toContentBlocks(msg.message);
+                content.push(...contentBlocks);
+                // event: thread.message.delta
+                const delta = {
+                    id: msgId,
+                    object: agent_runtime_1.AgentObjectType.ThreadMessageDelta,
+                    delta: { content: contentBlocks },
+                };
+                writer.writeEvent(agent_runtime_1.AgentSSEEvent.ThreadMessageDelta, delta);
+            }
+            if (msg.usage) {
+                hasUsage = true;
+                promptTokens += (_a = msg.usage.promptTokens) !== null && _a !== void 0 ? _a : 0;
+                completionTokens += (_b = msg.usage.completionTokens) !== null && _b !== void 0 ? _b : 0;
+            }
+        }
+        return {
+            content,
+            usage: hasUsage ? { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens } : undefined,
+            aborted: false,
+        };
+    }
+    async getRun(runId) {
+        const run = await this.store.getRun(runId);
+        return RunBuilder_1.RunBuilder.fromRecord(run).snapshot();
+    }
+    async cancelRun(runId) {
+        // 1. Check current status — reject if already terminal
+        const run = await this.store.getRun(runId);
+        if (AgentRuntime.TERMINAL_RUN_STATUSES.has(run.status)) {
+            throw new agent_runtime_1.AgentConflictError(`Cannot cancel run with status '${run.status}'`);
+        }
+        const rb = RunBuilder_1.RunBuilder.fromRecord(run);
+        // 2. Write "cancelling" to store first — visible to all workers
+        await this.store.updateRun(runId, rb.cancelling());
+        // 3. If the task is running locally, abort it for immediate effect
+        const task = this.runningTasks.get(runId);
+        if (task) {
+            task.abortController.abort();
+            await task.promise.catch(() => {
+                /* ignore */
+            });
+        }
+        // 4. Re-read store to mitigate TOCTOU: if the run completed/failed between
+        //    steps 2 and 4, do not overwrite the terminal state.
+        // TODO: For full atomicity, use CAS / ETag-based conditional writes.
+        const freshRun = await this.store.getRun(runId);
+        if (AgentRuntime.TERMINAL_RUN_STATUSES.has(freshRun.status)) {
+            // Run reached a terminal state while we were cancelling — return as-is
+            return RunBuilder_1.RunBuilder.fromRecord(freshRun).snapshot();
+        }
+        // 5. Transition to final "cancelled" state
+        try {
+            await this.store.updateRun(runId, rb.cancel());
+        }
+        catch (err) {
+            this.logger.error('[AgentRuntime] failed to write cancelled state after cancelling:', err);
+            // Return best-effort snapshot from store
+            const fallback = await this.store.getRun(runId);
+            return RunBuilder_1.RunBuilder.fromRecord(fallback).snapshot();
+        }
+        return rb.snapshot();
+    }
+    /** Wait for all in-flight background tasks to complete naturally (without aborting). */
+    async waitForPendingTasks() {
+        if (this.runningTasks.size) {
+            const pending = Array.from(this.runningTasks.values()).map(t => t.promise);
+            await Promise.allSettled(pending);
+        }
+    }
+    async destroy() {
+        // Abort all in-flight background tasks, then wait for them to settle
+        for (const task of this.runningTasks.values()) {
+            task.abortController.abort();
+        }
+        await this.waitForPendingTasks();
+        // Destroy store
+        if (this.store.destroy) {
+            await this.store.destroy();
+        }
+    }
+    /** Factory method — avoids the spread-arg type issue with dynamic delegation. */
+    static create(options) {
+        return new AgentRuntime(options);
+    }
+}
+exports.AgentRuntime = AgentRuntime;
+AgentRuntime.TERMINAL_RUN_STATUSES = new Set([
+    agent_runtime_1.RunStatus.Completed,
+    agent_runtime_1.RunStatus.Failed,
+    agent_runtime_1.RunStatus.Cancelled,
+    agent_runtime_1.RunStatus.Expired,
+]);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AgentRuntime.js","sourceRoot":"","sources":["../../src/AgentRuntime.ts"],"names":[],"mappings":"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"}

package/dist/src/AgentStore.d.ts

@@ -0,0 +1,42 @@
+import type { InputMessage, MessageObject, AgentRunConfig, RunStatus } from '@eggjs/controller-decorator';
+export interface ThreadRecord {
+    id: string;
+    object: 'thread';
+    messages: MessageObject[];
+    metadata: Record<string, unknown>;
+    created_at: number;
+}
+export interface RunRecord {
+    id: string;
+    object: 'thread.run';
+    thread_id?: string;
+    status: RunStatus;
+    input: InputMessage[];
+    output?: MessageObject[];
+    last_error?: {
+        code: string;
+        message: string;
+    } | null;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    } | null;
+    config?: AgentRunConfig;
+    metadata?: Record<string, unknown>;
+    created_at: number;
+    started_at?: number | null;
+    completed_at?: number | null;
+    cancelled_at?: number | null;
+    failed_at?: number | null;
+}
+export interface AgentStore {
+    init?(): Promise<void>;
+    destroy?(): Promise<void>;
+    createThread(metadata?: Record<string, unknown>): Promise<ThreadRecord>;
+    getThread(threadId: string): Promise<ThreadRecord>;
+    appendMessages(threadId: string, messages: MessageObject[]): Promise<void>;
+    createRun(input: InputMessage[], threadId?: string, config?: AgentRunConfig, metadata?: Record<string, unknown>): Promise<RunRecord>;
+    getRun(runId: string): Promise<RunRecord>;
+    updateRun(runId: string, updates: Partial<RunRecord>): Promise<void>;
+}

package/dist/src/AgentStore.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdlbnRTdG9yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9BZ2VudFN0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/src/AgentStoreUtils.d.ts

@@ -0,0 +1,4 @@
+export declare function nowUnix(): number;
+export declare function newMsgId(): string;
+export declare function newThreadId(): string;
+export declare function newRunId(): string;

package/dist/src/AgentStoreUtils.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nowUnix = nowUnix;
+exports.newMsgId = newMsgId;
+exports.newThreadId = newThreadId;
+exports.newRunId = newRunId;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+function nowUnix() {
+    return Math.floor(Date.now() / 1000);
+}
+function newMsgId() {
+    return `msg_${node_crypto_1.default.randomUUID()}`;
+}
+function newThreadId() {
+    return `thread_${node_crypto_1.default.randomUUID()}`;
+}
+function newRunId() {
+    return `run_${node_crypto_1.default.randomUUID()}`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdlbnRTdG9yZVV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL0FnZW50U3RvcmVVdGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUVBLDBCQUVDO0FBRUQsNEJBRUM7QUFFRCxrQ0FFQztBQUVELDRCQUVDO0FBaEJELDhEQUFpQztBQUVqQyxTQUFnQixPQUFPO0lBQ3JCLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLENBQUM7QUFDdkMsQ0FBQztBQUVELFNBQWdCLFFBQVE7SUFDdEIsT0FBTyxPQUFPLHFCQUFNLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQztBQUN0QyxDQUFDO0FBRUQsU0FBZ0IsV0FBVztJQUN6QixPQUFPLFVBQVUscUJBQU0sQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDO0FBQ3pDLENBQUM7QUFFRCxTQUFnQixRQUFRO0lBQ3RCLE9BQU8sT0FBTyxxQkFBTSxDQUFDLFVBQVUsRUFBRSxFQUFFLENBQUM7QUFDdEMsQ0FBQyJ9

package/dist/src/FileAgentStore.d.ts

@@ -0,0 +1,21 @@
+import type { InputMessage, MessageObject, AgentRunConfig } from '@eggjs/controller-decorator';
+import type { AgentStore, ThreadRecord, RunRecord } from './AgentStore';
+export interface FileAgentStoreOptions {
+    dataDir: string;
+}
+export declare class FileAgentStore implements AgentStore {
+    private readonly dataDir;
+    private readonly threadsDir;
+    private readonly runsDir;
+    constructor(options: FileAgentStoreOptions);
+    private safePath;
+    init(): Promise<void>;
+    createThread(metadata?: Record<string, unknown>): Promise<ThreadRecord>;
+    getThread(threadId: string): Promise<ThreadRecord>;
+    appendMessages(threadId: string, messages: MessageObject[]): Promise<void>;
+    createRun(input: InputMessage[], threadId?: string, config?: AgentRunConfig, metadata?: Record<string, unknown>): Promise<RunRecord>;
+    getRun(runId: string): Promise<RunRecord>;
+    updateRun(runId: string, updates: Partial<RunRecord>): Promise<void>;
+    private writeFile;
+    private readFile;
+}