@eggjs/agent-runtime 3.73.0-beta.0 → 4.0.2-beta.4

package/dist/OSSAgentStore.js

@@ -0,0 +1,133 @@
+import { newRunId, newThreadId, nowUnix } from "./AgentStoreUtils.js";
+import { AgentNotFoundError, AgentObjectType, RunStatus } from "@eggjs/tegg-types/agent-runtime";
+
+//#region src/OSSAgentStore.ts
+/**
+* AgentStore implementation backed by an ObjectStorageClient (OSS, S3, etc.).
+*
+* ## Storage layout
+*
+* ```
+* {prefix}threads/{id}/meta.json      — Thread metadata (JSON)
+* {prefix}threads/{id}/messages.jsonl  — Messages (JSONL, one JSON object per line)
+* {prefix}runs/{id}.json              — Run record (JSON)
+* ```
+*
+* ### Why split threads into two keys?
+*
+* Thread messages are append-only: new messages are added at the end but never
+* modified or deleted. Storing them as a JSONL file allows us to leverage the
+* OSS AppendObject API (or similar) to write new messages without reading the
+* entire thread first. This is much more efficient than read-modify-write for
+* long conversations.
+*
+* If the underlying ObjectStorageClient provides an `append()` method, it will
+* be used for O(1) message writes. Otherwise, the store falls back to
+* get-concat-put (which is NOT atomic and may lose data under concurrent
+* writers — acceptable for single-writer scenarios).
+*
+* ### Atomicity note
+*
+* Run updates still use read-modify-write because run fields are mutated
+* (status, timestamps, output, etc.) — they cannot be modelled as append-only.
+* For multi-writer safety, consider a database-backed AgentStore or ETag-based
+* conditional writes with retry.
+*/
+var OSSAgentStore = class {
+	client;
+	prefix;
+	constructor(options) {
+		this.client = options.client;
+		const raw = options.prefix ?? "";
+		this.prefix = raw && !raw.endsWith("/") ? raw + "/" : raw;
+	}
+	/** Key for thread metadata (JSON). */
+	threadMetaKey(threadId) {
+		return `${this.prefix}threads/${threadId}/meta.json`;
+	}
+	/** Key for thread messages (JSONL, one message per line). */
+	threadMessagesKey(threadId) {
+		return `${this.prefix}threads/${threadId}/messages.jsonl`;
+	}
+	/** Key for run record (JSON). */
+	runKey(runId) {
+		return `${this.prefix}runs/${runId}.json`;
+	}
+	async init() {
+		await this.client.init?.();
+	}
+	async destroy() {
+		await this.client.destroy?.();
+	}
+	async createThread(metadata) {
+		const threadId = newThreadId();
+		const meta = {
+			id: threadId,
+			object: AgentObjectType.Thread,
+			metadata: metadata ?? {},
+			createdAt: nowUnix()
+		};
+		await this.client.put(this.threadMetaKey(threadId), JSON.stringify(meta));
+		return {
+			...meta,
+			messages: []
+		};
+	}
+	async getThread(threadId) {
+		const [metaData, messagesData] = await Promise.all([this.client.get(this.threadMetaKey(threadId)), this.client.get(this.threadMessagesKey(threadId))]);
+		if (!metaData) throw new AgentNotFoundError(`Thread ${threadId} not found`);
+		const meta = JSON.parse(metaData);
+		const messages = messagesData ? messagesData.trim().split("\n").filter((line) => line.length > 0).map((line) => JSON.parse(line)) : [];
+		return {
+			...meta,
+			messages
+		};
+	}
+	/**
+	* Append messages to a thread.
+	*
+	* Each message is serialized as a single JSON line (JSONL format).
+	* When the underlying client supports `append()`, this is a single
+	* O(1) write — no need to read the existing messages first.
+	*/
+	async appendMessages(threadId, messages) {
+		if (!await this.client.get(this.threadMetaKey(threadId))) throw new AgentNotFoundError(`Thread ${threadId} not found`);
+		if (messages.length === 0) return;
+		const lines = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
+		const messagesKey = this.threadMessagesKey(threadId);
+		if (this.client.append) await this.client.append(messagesKey, lines);
+		else {
+			const existing = await this.client.get(messagesKey) ?? "";
+			await this.client.put(messagesKey, existing + lines);
+		}
+	}
+	async createRun(input, threadId, config, metadata) {
+		const runId = newRunId();
+		const record = {
+			id: runId,
+			object: AgentObjectType.ThreadRun,
+			threadId,
+			status: RunStatus.Queued,
+			input,
+			config,
+			metadata,
+			createdAt: nowUnix()
+		};
+		await this.client.put(this.runKey(runId), JSON.stringify(record));
+		return record;
+	}
+	async getRun(runId) {
+		const data = await this.client.get(this.runKey(runId));
+		if (!data) throw new AgentNotFoundError(`Run ${runId} not found`);
+		return JSON.parse(data);
+	}
+	async updateRun(runId, updates) {
+		const run = await this.getRun(runId);
+		const { id: _, object: __, ...safeUpdates } = updates;
+		Object.assign(run, safeUpdates);
+		await this.client.put(this.runKey(runId), JSON.stringify(run));
+	}
+};
+
+//#endregion
+export { OSSAgentStore };

package/dist/OSSObjectStorageClient.d.ts

@@ -0,0 +1,51 @@
+import { ObjectStorageClient } from "@eggjs/tegg-types/agent-runtime";
+import { OSSObject } from "oss-client";
+
+//#region src/OSSObjectStorageClient.d.ts
+
+/**
+* ObjectStorageClient backed by Alibaba Cloud OSS (via oss-client).
+*
+* Supports both `put`/`get` for normal objects and `append` for
+* OSS Appendable Objects. The append path uses a local position cache
+* to avoid extra HEAD requests; on position mismatch it falls back to
+* HEAD + retry automatically.
+*
+* The OSSObject instance should be constructed and injected by the caller,
+* following the IoC/DI principle.
+*/
+declare class OSSObjectStorageClient implements ObjectStorageClient {
+  private readonly client;
+  /**
+  * In-memory cache of next-append positions.
+  *
+  * After each successful `append()`, OSS returns `nextAppendPosition`.
+  * We cache it here so the next append can skip a HEAD round-trip.
+  * If the cached position is stale (e.g., process restarted or another
+  * writer appended), the append will fail with PositionNotEqualToLength
+  * and we fall back to HEAD + retry.
+  */
+  private readonly appendPositions;
+  constructor(client: OSSObject);
+  put(key: string, value: string): Promise<void>;
+  get(key: string): Promise<string | null>;
+  /**
+  * Append data to an OSS Appendable Object.
+  *
+  * OSS AppendObject requires a `position` parameter that must equal the
+  * current object size. We use a three-step strategy:
+  *
+  * 1. Use the cached position (0 for new objects, or the value from the
+  *    last successful append).
+  * 2. If OSS returns PositionNotEqualToLength (cache is stale), issue a
+  *    HEAD request to learn the current object size, then retry once.
+  * 3. Update the cache with `nextAppendPosition` from the response.
+  *
+  * This gives us single-round-trip performance in the common case (single
+  * writer, no restarts) while still being self-healing when the cache is
+  * stale.
+  */
+  append(key: string, value: string): Promise<void>;
+}
+//#endregion
+export { OSSObjectStorageClient };

package/dist/OSSObjectStorageClient.js

@@ -0,0 +1,78 @@
+//#region src/OSSObjectStorageClient.ts
+function isOSSError(err, code) {
+	return err != null && typeof err === "object" && "code" in err && err.code === code;
+}
+/**
+* ObjectStorageClient backed by Alibaba Cloud OSS (via oss-client).
+*
+* Supports both `put`/`get` for normal objects and `append` for
+* OSS Appendable Objects. The append path uses a local position cache
+* to avoid extra HEAD requests; on position mismatch it falls back to
+* HEAD + retry automatically.
+*
+* The OSSObject instance should be constructed and injected by the caller,
+* following the IoC/DI principle.
+*/
+var OSSObjectStorageClient = class {
+	client;
+	/**
+	* In-memory cache of next-append positions.
+	*
+	* After each successful `append()`, OSS returns `nextAppendPosition`.
+	* We cache it here so the next append can skip a HEAD round-trip.
+	* If the cached position is stale (e.g., process restarted or another
+	* writer appended), the append will fail with PositionNotEqualToLength
+	* and we fall back to HEAD + retry.
+	*/
+	appendPositions = /* @__PURE__ */ new Map();
+	constructor(client) {
+		this.client = client;
+	}
+	async put(key, value) {
+		await this.client.put(key, Buffer.from(value, "utf-8"));
+	}
+	async get(key) {
+		try {
+			const result = await this.client.get(key);
+			if (result.content) return Buffer.isBuffer(result.content) ? result.content.toString("utf-8") : String(result.content);
+			return null;
+		} catch (err) {
+			if (isOSSError(err, "NoSuchKey")) return null;
+			throw err;
+		}
+	}
+	/**
+	* Append data to an OSS Appendable Object.
+	*
+	* OSS AppendObject requires a `position` parameter that must equal the
+	* current object size. We use a three-step strategy:
+	*
+	* 1. Use the cached position (0 for new objects, or the value from the
+	*    last successful append).
+	* 2. If OSS returns PositionNotEqualToLength (cache is stale), issue a
+	*    HEAD request to learn the current object size, then retry once.
+	* 3. Update the cache with `nextAppendPosition` from the response.
+	*
+	* This gives us single-round-trip performance in the common case (single
+	* writer, no restarts) while still being self-healing when the cache is
+	* stale.
+	*/
+	async append(key, value) {
+		const buf = Buffer.from(value, "utf-8");
+		const position = this.appendPositions.get(key) ?? 0;
+		try {
+			const result = await this.client.append(key, buf, { position });
+			this.appendPositions.set(key, Number(result.nextAppendPosition));
+		} catch (err) {
+			if (isOSSError(err, "PositionNotEqualToLength")) {
+				const head = await this.client.head(key);
+				const currentPos = Number(head.res.headers["content-length"] ?? 0);
+				const result = await this.client.append(key, buf, { position: currentPos });
+				this.appendPositions.set(key, Number(result.nextAppendPosition));
+			} else throw err;
+		}
+	}
+};
+
+//#endregion
+export { OSSObjectStorageClient };

package/dist/RunBuilder.d.ts

@@ -0,0 +1,47 @@
+import { MessageObject, RunObject, RunRecord } from "@eggjs/tegg-types/agent-runtime";
+
+//#region src/RunBuilder.d.ts
+/** Accumulated token usage — same shape as non-null RunRecord['usage']. */
+type RunUsage = NonNullable<RunRecord["usage"]>;
+/**
+* Encapsulates run state transitions.
+*
+* Mutation methods (`start`, `complete`, `fail`, `cancel`) update internal
+* state and return `Partial<RunRecord>` for the store.
+*
+* `snapshot()` produces a `RunObject` suitable for API responses and SSE events.
+*/
+declare class RunBuilder {
+  private readonly id;
+  private readonly threadId;
+  private readonly createdAt;
+  private readonly metadata?;
+  private readonly config?;
+  private status;
+  private startedAt?;
+  private completedAt?;
+  private cancelledAt?;
+  private failedAt?;
+  private lastError?;
+  private usage?;
+  private output?;
+  private constructor();
+  /** Create a RunBuilder from a store RunRecord, using its own threadId. */
+  static fromRecord(run: RunRecord): RunBuilder;
+  /** Create a RunBuilder from a store RunRecord, restoring all mutable state. */
+  static create(run: RunRecord, threadId: string): RunBuilder;
+  /** queued -> in_progress. Returns store update. */
+  start(): Partial<RunRecord>;
+  /** in_progress -> completed. Returns store update. */
+  complete(output: MessageObject[], usage?: RunUsage): Partial<RunRecord>;
+  /** queued/in_progress -> failed. Returns store update. */
+  fail(error: Error): Partial<RunRecord>;
+  /** in_progress/queued -> cancelling (idempotent if already cancelling). Returns store update. */
+  cancelling(): Partial<RunRecord>;
+  /** cancelling -> cancelled. Returns store update. */
+  cancel(): Partial<RunRecord>;
+  /** Produce a RunObject snapshot for API / SSE. */
+  snapshot(): RunObject;
+}
+//#endregion
+export { RunBuilder, RunUsage };

package/dist/RunBuilder.js

@@ -0,0 +1,129 @@
+import { nowUnix } from "./AgentStoreUtils.js";
+import { AgentErrorCode, AgentObjectType, InvalidRunStateTransitionError, RunStatus } from "@eggjs/tegg-types/agent-runtime";
+
+//#region src/RunBuilder.ts
+/**
+* Encapsulates run state transitions.
+*
+* Mutation methods (`start`, `complete`, `fail`, `cancel`) update internal
+* state and return `Partial<RunRecord>` for the store.
+*
+* `snapshot()` produces a `RunObject` suitable for API responses and SSE events.
+*/
+var RunBuilder = class RunBuilder {
+	id;
+	threadId;
+	createdAt;
+	metadata;
+	config;
+	status;
+	startedAt;
+	completedAt;
+	cancelledAt;
+	failedAt;
+	lastError;
+	usage;
+	output;
+	constructor(id, threadId, createdAt, status, metadata, config) {
+		this.id = id;
+		this.threadId = threadId;
+		this.createdAt = createdAt;
+		this.status = status;
+		this.metadata = metadata;
+		this.config = config;
+	}
+	/** Create a RunBuilder from a store RunRecord, using its own threadId. */
+	static fromRecord(run) {
+		return RunBuilder.create(run, run.threadId ?? "");
+	}
+	/** Create a RunBuilder from a store RunRecord, restoring all mutable state. */
+	static create(run, threadId) {
+		const rb = new RunBuilder(run.id, threadId, run.createdAt, run.status, run.metadata, run.config);
+		rb.startedAt = run.startedAt ?? void 0;
+		rb.completedAt = run.completedAt ?? void 0;
+		rb.cancelledAt = run.cancelledAt ?? void 0;
+		rb.failedAt = run.failedAt ?? void 0;
+		rb.lastError = run.lastError ?? void 0;
+		rb.output = run.output;
+		if (run.usage) rb.usage = { ...run.usage };
+		return rb;
+	}
+	/** queued -> in_progress. Returns store update. */
+	start() {
+		if (this.status !== RunStatus.Queued) throw new InvalidRunStateTransitionError(this.status, RunStatus.InProgress);
+		this.status = RunStatus.InProgress;
+		this.startedAt = nowUnix();
+		return {
+			status: this.status,
+			startedAt: this.startedAt
+		};
+	}
+	/** in_progress -> completed. Returns store update. */
+	complete(output, usage) {
+		if (this.status !== RunStatus.InProgress) throw new InvalidRunStateTransitionError(this.status, RunStatus.Completed);
+		this.status = RunStatus.Completed;
+		this.completedAt = nowUnix();
+		this.output = output;
+		this.usage = usage;
+		return {
+			status: this.status,
+			output,
+			usage,
+			completedAt: this.completedAt
+		};
+	}
+	/** queued/in_progress -> failed. Returns store update. */
+	fail(error) {
+		if (this.status !== RunStatus.InProgress && this.status !== RunStatus.Queued) throw new InvalidRunStateTransitionError(this.status, RunStatus.Failed);
+		this.status = RunStatus.Failed;
+		this.failedAt = nowUnix();
+		this.lastError = {
+			code: AgentErrorCode.ExecError,
+			message: error.message
+		};
+		return {
+			status: this.status,
+			lastError: this.lastError,
+			failedAt: this.failedAt
+		};
+	}
+	/** in_progress/queued -> cancelling (idempotent if already cancelling). Returns store update. */
+	cancelling() {
+		if (this.status === RunStatus.Cancelling) return { status: this.status };
+		if (this.status !== RunStatus.InProgress && this.status !== RunStatus.Queued) throw new InvalidRunStateTransitionError(this.status, RunStatus.Cancelling);
+		this.status = RunStatus.Cancelling;
+		return { status: this.status };
+	}
+	/** cancelling -> cancelled. Returns store update. */
+	cancel() {
+		if (this.status !== RunStatus.Cancelling) throw new InvalidRunStateTransitionError(this.status, RunStatus.Cancelled);
+		this.status = RunStatus.Cancelled;
+		this.cancelledAt = nowUnix();
+		return {
+			status: this.status,
+			cancelledAt: this.cancelledAt
+		};
+	}
+	/** Produce a RunObject snapshot for API / SSE. */
+	snapshot() {
+		return {
+			id: this.id,
+			object: AgentObjectType.ThreadRun,
+			createdAt: this.createdAt,
+			threadId: this.threadId,
+			status: this.status,
+			lastError: this.lastError,
+			startedAt: this.startedAt ?? null,
+			completedAt: this.completedAt ?? null,
+			cancelledAt: this.cancelledAt ?? null,
+			failedAt: this.failedAt ?? null,
+			usage: this.usage ?? null,
+			metadata: this.metadata,
+			output: this.output,
+			config: this.config
+		};
+	}
+};
+
+//#endregion
+export { RunBuilder };

package/dist/SSEWriter.d.ts

@@ -0,0 +1,17 @@
+//#region src/SSEWriter.d.ts
+/**
+* Abstract interface for writing SSE events.
+* Decouples AgentRuntime from HTTP transport details.
+*/
+interface SSEWriter {
+  /** Write an SSE event with the given name and JSON-serializable data. */
+  writeEvent(event: string, data: unknown): void;
+  /** Whether the underlying connection has been closed. */
+  readonly closed: boolean;
+  /** End the SSE stream. */
+  end(): void;
+  /** Register a callback for when the client disconnects. */
+  onClose(callback: () => void): void;
+}
+//#endregion
+export { SSEWriter };

package/dist/SSEWriter.js

@@ -0,0 +1 @@
+export {  };

package/dist/index.d.ts

@@ -1,10 +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';
+import { SSEWriter } from "./SSEWriter.js";
+import { AGENT_RUNTIME, AgentExecutor, AgentRuntime, AgentRuntimeOptions } from "./AgentRuntime.js";
+import { newMsgId, newRunId, newThreadId, nowUnix } from "./AgentStoreUtils.js";
+import { HttpSSEWriter } from "./HttpSSEWriter.js";
+import { RunBuilder, RunUsage } from "./RunBuilder.js";
+import { MessageConverter } from "./MessageConverter.js";
+import { OSSAgentStore, OSSAgentStoreOptions } from "./OSSAgentStore.js";
+import { OSSObjectStorageClient } from "./OSSObjectStorageClient.js";
+export * from "@eggjs/tegg-types/agent-runtime";
+export { AGENT_RUNTIME, type AgentExecutor, AgentRuntime, type AgentRuntimeOptions, HttpSSEWriter, MessageConverter, OSSAgentStore, OSSAgentStoreOptions, OSSObjectStorageClient, RunBuilder, RunUsage, SSEWriter, newMsgId, newRunId, newThreadId, nowUnix };

package/dist/index.js

@@ -1,31 +1,11 @@
-"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=
+import { newMsgId, newRunId, newThreadId, nowUnix } from "./AgentStoreUtils.js";
+import { MessageConverter } from "./MessageConverter.js";
+import { RunBuilder } from "./RunBuilder.js";
+import { AGENT_RUNTIME, AgentRuntime } from "./AgentRuntime.js";
+import { HttpSSEWriter } from "./HttpSSEWriter.js";
+import { OSSAgentStore } from "./OSSAgentStore.js";
+import { OSSObjectStorageClient } from "./OSSObjectStorageClient.js";
+
+export * from "@eggjs/tegg-types/agent-runtime"
+
+export { AGENT_RUNTIME, AgentRuntime, HttpSSEWriter, MessageConverter, OSSAgentStore, OSSObjectStorageClient, RunBuilder, newMsgId, newRunId, newThreadId, nowUnix };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/agent-runtime",
-  "version": "3.73.0-beta.0",
+  "version": "4.0.2-beta.4",
   "description": "Agent runtime with store abstraction for Egg.js tegg",
   "keywords": [
     "agent",
@@ -9,42 +9,52 @@
     "store",
     "tegg"
   ],
-  "homepage": "https://github.com/eggjs/tegg/tree/master/core/agent-runtime",
+  "homepage": "https://github.com/eggjs/egg/tree/next/tegg/core/agent-runtime",
   "bugs": {
-    "url": "https://github.com/eggjs/tegg/issues"
+    "url": "https://github.com/eggjs/egg/issues"
   },
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/eggjs/tegg.git",
-    "directory": "core/agent-runtime"
+    "url": "git+https://github.com/eggjs/egg.git",
+    "directory": "tegg/core/agent-runtime"
   },
   "files": [
-    "dist",
-    "index.js",
-    "index.d.ts"
+    "dist"
   ],
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "tsc": "tsc -p tsconfig.json",
-    "tsc:pub": "tsc -p tsconfig.pub.json",
-    "prepublishOnly": "npm run tsc:pub",
-    "test": "mocha"
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./AgentRuntime": "./dist/AgentRuntime.js",
+    "./AgentStoreUtils": "./dist/AgentStoreUtils.js",
+    "./HttpSSEWriter": "./dist/HttpSSEWriter.js",
+    "./MessageConverter": "./dist/MessageConverter.js",
+    "./OSSAgentStore": "./dist/OSSAgentStore.js",
+    "./OSSObjectStorageClient": "./dist/OSSObjectStorageClient.js",
+    "./RunBuilder": "./dist/RunBuilder.js",
+    "./SSEWriter": "./dist/SSEWriter.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@eggjs/tegg-types": "^3.73.0-beta.0",
-    "egg-logger": "^3.0.1",
-    "oss-client": "^2.5.1"
+    "egg-logger": "^3.5.0",
+    "oss-client": "^2.5.1",
+    "@eggjs/tegg-types": "4.0.2-beta.4"
   },
   "devDependencies": {
-    "@types/mocha": "^10.0.0",
-    "@types/node": "^20.0.0",
-    "mocha": "^10.0.0",
-    "typescript": "^5.0.0"
+    "@types/node": "^24.10.2",
+    "typescript": "^5.9.3"
   },
   "engines": {
-    "node": ">= 16.0.0"
+    "node": ">=22.18.0"
   },
-  "gitHead": "419d966f3efc649e533f165ba5d15994d7076722"
-}
+  "scripts": {
+    "typecheck": "tsgo --noEmit",
+    "test": "vitest run"
+  }
+}

package/dist/src/AgentRuntime.d.ts

@@ -1,42 +0,0 @@
-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;
-}