@modelprofile.com/flexharness-agent 6.0.0 → 7.0.0

package/dist_ts_agent/index.d.ts

@@ -5,9 +5,9 @@ export { filterModelVisibleAgentEvents, getAgentGenerationTransactions, getOpenA
 export { createAgentEvent, createAgentEventId, modelMessagesToAgentEvents, } from './smartagent.events.js';
 export { ToolRegistry } from './smartagent.classes.toolregistry.js';
 export { AgentGenerationLeaseCleanupError, ContextOverflowError, } from './smartagent.interfaces.js';
-export { AgentEventStoreConflictError, FileAgentEventStore, InMemoryAgentEventStore, isAgentEventStoreV2, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, } from './smartagent.persistence.js';
+export { AgentEventStoreConflictError, InMemoryAgentEventStore, isAgentEventStoreV2, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, } from './smartagent.persistence.js';
 export type { IAgentCacheOptions, IAgentContextOverflowInvocationOptions, IAgentContextBuildOptions, IAgentContextCompactionOptions, IAgentCompactOptions, IAgentEventRetentionOptions, IAgentBeginGenerationOptions, IAgentGenerateOptions, IAgentGenerateResult, IAgentGenerationHandle, IAgentGenerationLease, IAgentGenerationPreparationContext, IAgentRunOptions, IAgentRunResult, IAgentSession, IAgentSessionAbortOptions, IAgentSessionChange, IAgentSessionOptions, IAgentScheduleGenerateOptions, IAgentToolCallRecord, IAgentToolCallStartEvent, IAgentToolCallUpdateEvent, ProviderOptions, TAgentCacheRetention, TAgentCacheSetting, TAgentPrompt, TAgentContextBuilder, TAgentContextCompactor, TAgentGenerationPrepare, TAgentSessionChangeListener, TAgentToolCallFinishEvent, TAgentToolExecutionReconciliationOptions, } from './smartagent.interfaces.js';
-export type { IAgentEventArchive, IAgentEventArchiveV2, IAgentEventSnapshot, IAgentEventSnapshotV2, IAgentEventStore, IAgentEventStoreV2, IFileAgentEventStoreOptions, TAgentEventArchive, TAgentEventSnapshot, TAgentEventStore, } from './smartagent.persistence.js';
+export type { IAgentEventArchive, IAgentEventArchiveV2, IAgentEventSnapshot, IAgentEventSnapshotV2, IAgentEventStore, IAgentEventStoreV2, TAgentEventArchive, TAgentEventSnapshot, TAgentEventStore, } from './smartagent.persistence.js';
 export type { IAgentEventBase, IAgentRuntimeEventPayload, IArchivedAgentGenerationTransaction, IAssistantMessageEvent, IContextCompactionEvent, IGenerationBegunEvent, IGenerationExecutionCompletedEvent, IGenerationExecutionStartedEvent, IGenerationOutcomeEvent, IModelMessageEvent, IModelMessagesToEventsOptions, IModelMessageEventIdentityCoordinates, IRuntimeEvent, ISystemMessageEvent, IToolCallEvent, IToolExecutionIntentEvent, IToolExecutionReconciliationEvent, IToolResultEvent, IUserMessageEvent, TAgentAssistantMessage, TAgentConversationEvent, TAgentControlEvent, TAgentEvent, TAgentEventInput, TAgentSystemMessage, TAgentGenerationOutcome, TAgentToolCallPart, TAgentToolMessage, TAgentToolResultOutput, TAgentToolResultPart, TAgentUserMessage, TModelMessageEmittedEventKind, TModelMessageEventIdentityFactory, TToolExecutionReconciliation, } from './smartagent.events.js';
 export type { IAgentGenerationTransaction, TAgentGenerationTransactionState, } from './smartagent.transactions.js';
 export * from './tool.contracts.js';
@@ -15,3 +15,4 @@ export * from './tool.persistence.js';
 export * from './tool.adapter.js';
 export { tool, jsonSchema, stepCountIs } from 'ai';
 export { z } from 'zod';
+export { FileAgentEventStore, type IFileAgentEventStoreOptions } from './persistence.file.js';

package/dist_ts_agent/index.js

@@ -5,10 +5,11 @@ export { filterModelVisibleAgentEvents, getAgentGenerationTransactions, getOpenA
 export { createAgentEvent, createAgentEventId, modelMessagesToAgentEvents, } from './smartagent.events.js';
 export { ToolRegistry } from './smartagent.classes.toolregistry.js';
 export { AgentGenerationLeaseCleanupError, ContextOverflowError, } from './smartagent.interfaces.js';
-export { AgentEventStoreConflictError, FileAgentEventStore, InMemoryAgentEventStore, isAgentEventStoreV2, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, } from './smartagent.persistence.js';
+export { AgentEventStoreConflictError, InMemoryAgentEventStore, isAgentEventStoreV2, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, } from './smartagent.persistence.js';
 export * from './tool.contracts.js';
 export * from './tool.persistence.js';
 export * from './tool.adapter.js';
 export { tool, jsonSchema, stepCountIs } from 'ai';
 export { z } from 'zod';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19hZ2VudC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDekQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQy9ELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzdELE9BQU8sRUFDTCw2QkFBNkIsRUFDN0IsOEJBQThCLEVBQzlCLGtDQUFrQyxFQUNsQyxnQ0FBZ0MsRUFDaEMseUJBQXlCLEdBQzFCLE1BQU0sOEJBQThCLENBQUM7QUFDdEMsT0FBTyxFQUNMLGdCQUFnQixFQUNoQixrQkFBa0IsRUFDbEIsMEJBQTBCLEdBQzNCLE1BQU0sd0JBQXdCLENBQUM7QUFDaEMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ3BFLE9BQU8sRUFDTCxnQ0FBZ0MsRUFDaEMsb0JBQW9CLEdBQ3JCLE1BQU0sNEJBQTRCLENBQUM7QUFDcEMsT0FBTyxFQUNMLDRCQUE0QixFQUM1QixtQkFBbUIsRUFDbkIsdUJBQXVCLEVBQ3ZCLG1CQUFtQixFQUNuQiwyQkFBMkIsRUFDM0IsNEJBQTRCLEdBQzdCLE1BQU0sNkJBQTZCLENBQUM7QUF1RnJDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLE9BQU8sRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxNQUFNLElBQUksQ0FBQztBQUNuRCxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDIn0=
+export { FileAgentEventStore } from './persistence.file.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19hZ2VudC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDekQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQy9ELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzdELE9BQU8sRUFDTCw2QkFBNkIsRUFDN0IsOEJBQThCLEVBQzlCLGtDQUFrQyxFQUNsQyxnQ0FBZ0MsRUFDaEMseUJBQXlCLEdBQzFCLE1BQU0sOEJBQThCLENBQUM7QUFDdEMsT0FBTyxFQUNMLGdCQUFnQixFQUNoQixrQkFBa0IsRUFDbEIsMEJBQTBCLEdBQzNCLE1BQU0sd0JBQXdCLENBQUM7QUFDaEMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ3BFLE9BQU8sRUFDTCxnQ0FBZ0MsRUFDaEMsb0JBQW9CLEdBQ3JCLE1BQU0sNEJBQTRCLENBQUM7QUFDcEMsT0FBTyxFQUNMLDRCQUE0QixFQUM1Qix1QkFBdUIsRUFDdkIsbUJBQW1CLEVBQ25CLDJCQUEyQixFQUMzQiw0QkFBNEIsR0FDN0IsTUFBTSw2QkFBNkIsQ0FBQztBQXNGckMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsT0FBTyxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsV0FBVyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ25ELE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsT0FBTyxFQUFFLG1CQUFtQixFQUFvQyxNQUFNLHVCQUF1QixDQUFDIn0=

package/dist_ts_agent/persistence.file.d.ts

@@ -0,0 +1,24 @@
+import type { TAgentEvent } from './smartagent.events.js';
+import { type IAgentEventArchiveV2, type IAgentEventStoreV2, type TAgentEventArchive, type TAgentEventSnapshot } from './smartagent.persistence.js';
+export interface IFileAgentEventStoreOptions {
+    rootDir: string;
+    /** Maximum time spent waiting for another writer. Default: 10 seconds. */
+    lockTimeoutMs?: number;
+}
+export declare class FileAgentEventStore implements IAgentEventStoreV2 {
+    readonly eventSchemaVersion: 2;
+    private readonly rootDir;
+    private readonly lockTimeoutMs;
+    constructor(options: IFileAgentEventStoreOptions);
+    private sessionKey;
+    private snapshotPath;
+    private archivePath;
+    private readValue;
+    private syncDirectory;
+    private writeAtomic;
+    private withSessionLock;
+    load(sessionId: string): Promise<TAgentEventSnapshot | undefined>;
+    save(sessionId: string, events: readonly TAgentEvent[], expectedRevision: number): Promise<number>;
+    archive(archive: IAgentEventArchiveV2): Promise<void>;
+    loadArchive(sessionId: string, archiveId: string): Promise<TAgentEventArchive | undefined>;
+}

package/dist_ts_agent/persistence.file.js

@@ -0,0 +1,199 @@
+import * as plugins from './plugins.node.js';
+import { AgentEventStoreConflictError, clone, createSnapshot, validateAgentEventArchiveV2, validateAgentEventSnapshotV2, } from './smartagent.persistence.js';
+const SNAPSHOT_SCHEMA_VERSION = 2;
+const ARCHIVE_SCHEMA_VERSION = 2;
+const assertSessionId = (sessionId) => {
+    if (!sessionId.trim())
+        throw new Error('Agent event store sessionId must not be empty.');
+};
+const decodeSnapshot = (value, sessionId) => {
+    const snapshot = value;
+    if (snapshot?.schemaVersion === SNAPSHOT_SCHEMA_VERSION) {
+        try {
+            return validateAgentEventSnapshotV2(value, sessionId);
+        }
+        catch {
+            throw new Error(`Invalid agent event snapshot for session "${sessionId}".`);
+        }
+    }
+    if (!snapshot
+        || snapshot.schemaVersion !== 1
+        || snapshot.sessionId !== sessionId
+        || !Number.isSafeInteger(snapshot.revision)
+        || (snapshot.revision ?? -1) < 1
+        || !Array.isArray(snapshot.events)) {
+        throw new Error(`Invalid agent event snapshot for session "${sessionId}".`);
+    }
+    return snapshot;
+};
+const decodeArchive = (value, sessionId, archiveId) => {
+    const archive = value;
+    if (archive?.schemaVersion === ARCHIVE_SCHEMA_VERSION) {
+        try {
+            return validateAgentEventArchiveV2(value, sessionId, archiveId);
+        }
+        catch {
+            throw new Error(`Invalid agent event archive "${archiveId}" for session "${sessionId}".`);
+        }
+    }
+    if (!archive
+        || archive.schemaVersion !== 1
+        || archive.sessionId !== sessionId
+        || archive.archiveId !== archiveId
+        || !Array.isArray(archive.events)) {
+        throw new Error(`Invalid agent event archive "${archiveId}" for session "${sessionId}".`);
+    }
+    return archive;
+};
+const sleep = async (milliseconds) => {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+};
+export class FileAgentEventStore {
+    eventSchemaVersion = 2;
+    rootDir;
+    lockTimeoutMs;
+    constructor(options) {
+        if (!options.rootDir.trim())
+            throw new Error('FileAgentEventStore rootDir must not be empty.');
+        this.rootDir = plugins.path.resolve(options.rootDir);
+        this.lockTimeoutMs = options.lockTimeoutMs ?? 10_000;
+        if (!Number.isSafeInteger(this.lockTimeoutMs) || this.lockTimeoutMs <= 0) {
+            throw new Error('lockTimeoutMs must be a positive integer.');
+        }
+    }
+    sessionKey(sessionId) {
+        assertSessionId(sessionId);
+        return plugins.crypto.createHash('sha256').update(sessionId).digest('hex');
+    }
+    snapshotPath(sessionId) {
+        return plugins.path.join(this.rootDir, 'sessions', `${this.sessionKey(sessionId)}.bin`);
+    }
+    archivePath(sessionId, archiveId) {
+        if (!archiveId.trim())
+            throw new Error('Agent event archiveId must not be empty.');
+        const archiveKey = plugins.crypto.createHash('sha256').update(archiveId).digest('hex');
+        return plugins.path.join(this.rootDir, 'archives', this.sessionKey(sessionId), `${archiveKey}.bin`);
+    }
+    async readValue(filePath) {
+        try {
+            return plugins.v8.deserialize(await plugins.fs.readFile(filePath));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        }
+    }
+    async syncDirectory(directoryPath) {
+        const handle = await plugins.fs.open(directoryPath, 'r');
+        try {
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async writeAtomic(filePath, value) {
+        const directoryPath = plugins.path.dirname(filePath);
+        await plugins.fs.mkdir(directoryPath, { recursive: true });
+        const temporaryPath = `${filePath}.${process.pid}.${plugins.crypto.randomUUID()}.tmp`;
+        let handle;
+        try {
+            handle = await plugins.fs.open(temporaryPath, 'wx');
+            await handle.writeFile(plugins.v8.serialize(value));
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await plugins.fs.rename(temporaryPath, filePath);
+            await this.syncDirectory(directoryPath);
+        }
+        finally {
+            if (handle)
+                await handle.close().catch(() => undefined);
+            await plugins.fs.rm(temporaryPath, { force: true });
+        }
+    }
+    async withSessionLock(sessionId, operation) {
+        const lockPath = plugins.path.join(this.rootDir, 'locks', `${this.sessionKey(sessionId)}.lock`);
+        const ownerPath = plugins.path.join(lockPath, 'owner');
+        const ownerToken = plugins.crypto.randomUUID();
+        const ownerRecord = JSON.stringify({ token: ownerToken });
+        await plugins.fs.mkdir(plugins.path.dirname(lockPath), { recursive: true });
+        const startedAt = Date.now();
+        while (true) {
+            try {
+                await plugins.fs.mkdir(lockPath);
+                try {
+                    await plugins.fs.writeFile(ownerPath, ownerRecord, 'utf8');
+                }
+                catch (error) {
+                    await plugins.fs.rm(lockPath, { recursive: true, force: true });
+                    throw error;
+                }
+                break;
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                if (Date.now() - startedAt >= this.lockTimeoutMs) {
+                    throw new Error(`Timed out waiting for the event-store lock for session "${sessionId}" at "${lockPath}".`);
+                }
+                await sleep(20);
+            }
+        }
+        try {
+            return await operation();
+        }
+        finally {
+            let stillOwner = false;
+            try {
+                const owner = JSON.parse(await plugins.fs.readFile(ownerPath, 'utf8'));
+                stillOwner = owner.token === ownerToken;
+            }
+            catch { }
+            if (stillOwner)
+                await plugins.fs.rm(lockPath, { recursive: true, force: true });
+        }
+    }
+    async load(sessionId) {
+        const value = await this.readValue(this.snapshotPath(sessionId));
+        return value === undefined ? undefined : decodeSnapshot(value, sessionId);
+    }
+    async save(sessionId, events, expectedRevision) {
+        return this.withSessionLock(sessionId, async () => {
+            const filePath = this.snapshotPath(sessionId);
+            const currentValue = await this.readValue(filePath);
+            const actualRevision = currentValue === undefined
+                ? 0
+                : decodeSnapshot(currentValue, sessionId).revision;
+            if (actualRevision !== expectedRevision) {
+                throw new AgentEventStoreConflictError(sessionId, expectedRevision, actualRevision);
+            }
+            const revision = expectedRevision + 1;
+            await this.writeAtomic(filePath, createSnapshot(sessionId, revision, events));
+            return revision;
+        });
+    }
+    async archive(archive) {
+        const nextArchive = clone(archive);
+        await this.withSessionLock(archive.sessionId, async () => {
+            const filePath = this.archivePath(archive.sessionId, archive.archiveId);
+            const currentValue = await this.readValue(filePath);
+            if (currentValue !== undefined) {
+                const current = decodeArchive(currentValue, archive.sessionId, archive.archiveId);
+                const currentIds = current.events.map((event) => event.id).join('\n');
+                const nextIds = nextArchive.events.map((event) => event.id).join('\n');
+                if (currentIds !== nextIds) {
+                    throw new Error(`Archive "${archive.archiveId}" already exists with different events.`);
+                }
+                return;
+            }
+            await this.writeAtomic(filePath, nextArchive);
+        });
+    }
+    async loadArchive(sessionId, archiveId) {
+        const value = await this.readValue(this.archivePath(sessionId, archiveId));
+        return value === undefined ? undefined : decodeArchive(value, sessionId, archiveId);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"persistence.file.js","sourceRoot":"","sources":["../ts_agent/persistence.file.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAC;AAE7C,OAAO,EACL,4BAA4B,EAAE,KAAK,EAAE,cAAc,EACnD,2BAA2B,EAAE,4BAA4B,GAG1D,MAAM,6BAA6B,CAAC;AAErC,MAAM,uBAAuB,GAAG,CAAU,CAAC;AAC3C,MAAM,sBAAsB,GAAG,CAAU,CAAC;AAQ1C,MAAM,eAAe,GAAG,CAAC,SAAiB,EAAQ,EAAE;IAClD,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;AAC3F,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,CAAC,KAAc,EAAE,SAAiB,EAAuB,EAAE;IAChF,MAAM,QAAQ,GAAG,KAAqC,CAAC;IACvD,IAAI,QAAQ,EAAE,aAAa,KAAK,uBAAuB,EAAE,CAAC;QACxD,IAAI,CAAC;YACH,OAAO,4BAA4B,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QACxD,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,IAAI,KAAK,CAAC,6CAA6C,SAAS,IAAI,CAAC,CAAC;QAC9E,CAAC;IACH,CAAC;IACD,IACE,CAAC,QAAQ;WACN,QAAQ,CAAC,aAAa,KAAK,CAAC;WAC5B,QAAQ,CAAC,SAAS,KAAK,SAAS;WAChC,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC;WACxC,CAAC,QAAQ,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC;WAC7B,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAClC,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,6CAA6C,SAAS,IAAI,CAAC,CAAC;IAC9E,CAAC;IACD,OAAO,QAA+B,CAAC;AACzC,CAAC,CAAC;AAEF,MAAM,aAAa,GAAG,CACpB,KAAc,EACd,SAAiB,EACjB,SAAiB,EACG,EAAE;IACtB,MAAM,OAAO,GAAG,KAAoC,CAAC;IACrD,IAAI,OAAO,EAAE,aAAa,KAAK,sBAAsB,EAAE,CAAC;QACtD,IAAI,CAAC;YACH,OAAO,2BAA2B,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QAClE,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,IAAI,KAAK,CAAC,gCAAgC,SAAS,kBAAkB,SAAS,IAAI,CAAC,CAAC;QAC5F,CAAC;IACH,CAAC;IACD,IACE,CAAC,OAAO;WACL,OAAO,CAAC,aAAa,KAAK,CAAC;WAC3B,OAAO,CAAC,SAAS,KAAK,SAAS;WAC/B,OAAO,CAAC,SAAS,KAAK,SAAS;WAC/B,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EACjC,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,gCAAgC,SAAS,kBAAkB,SAAS,IAAI,CAAC,CAAC;IAC5F,CAAC;IACD,OAAO,OAA6B,CAAC;AACvC,CAAC,CAAC;AAEF,MAAM,KAAK,GAAG,KAAK,EAAE,YAAoB,EAAiB,EAAE;IAC1D,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;AACpE,CAAC,CAAC;AAEF,MAAM,OAAO,mBAAmB;IACd,kBAAkB,GAAG,CAAU,CAAC;IAC/B,OAAO,CAAS;IAChB,aAAa,CAAS;IAEvC,YAAY,OAAoC;QAC9C,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE;YAAE,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;QAC/F,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACrD,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,MAAM,CAAC;QACrD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,EAAE,CAAC;YACzE,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;IAEO,UAAU,CAAC,SAAiB;QAClC,eAAe,CAAC,SAAS,CAAC,CAAC;QAC3B,OAAO,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC7E,CAAC;IAEO,YAAY,CAAC,SAAiB;QACpC,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAC1F,CAAC;IAEO,WAAW,CAAC,SAAiB,EAAE,SAAiB;QACtD,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE;YAAE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QACnF,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACvF,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,GAAG,UAAU,MAAM,CAAC,CAAC;IACtG,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,QAAgB;QACtC,IAAI,CAAC;YACH,OAAO,OAAO,CAAC,EAAE,CAAC,WAAW,CAAC,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;QACrE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAK,KAA+B,CAAC,IAAI,KAAK,QAAQ;gBAAE,OAAO,SAAS,CAAC;YACzE,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,aAAa,CAAC,aAAqB;QAC/C,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC;QACzD,IAAI,CAAC;YACH,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;QACtB,CAAC;gBAAS,CAAC;YACT,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACvB,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,WAAW,CAAC,QAAgB,EAAE,KAAc;QACxD,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACrD,MAAM,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,aAAa,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3D,MAAM,aAAa,GAAG,GAAG,QAAQ,IAAI,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC;QACtF,IAAI,MAA+D,CAAC;QACpE,IAAI,CAAC;YACH,MAAM,GAAG,MAAM,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;YACpD,MAAM,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;YACpD,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;YACpB,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;YACrB,MAAM,GAAG,SAAS,CAAC;YACnB,MAAM,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;YACjD,MAAM,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;QAC1C,CAAC;gBAAS,CAAC;YACT,IAAI,MAAM;gBAAE,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YACxD,MAAM,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,aAAa,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,eAAe,CAC3B,SAAiB,EACjB,SAAgC;QAEhC,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAChG,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QACvD,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QAC/C,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;QAC1D,MAAM,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5E,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,OAAO,IAAI,EAAE,CAAC;YACZ,IAAI,CAAC;gBACH,MAAM,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;gBACjC,IAAI,CAAC;oBACH,MAAM,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;gBAC7D,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;oBAChE,MAAM,KAAK,CAAC;gBACd,CAAC;gBACD,MAAM;YACR,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAK,KAA+B,CAAC,IAAI,KAAK,QAAQ;oBAAE,MAAM,KAAK,CAAC;gBACpE,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;oBACjD,MAAM,IAAI,KAAK,CACb,2DAA2D,SAAS,SAAS,QAAQ,IAAI,CAC1F,CAAC;gBACJ,CAAC;gBACD,MAAM,KAAK,CAAC,EAAE,CAAC,CAAC;YAClB,CAAC;QACH,CAAC;QACD,IAAI,CAAC;YACH,OAAO,MAAM,SAAS,EAAE,CAAC;QAC3B,CAAC;gBAAS,CAAC;YACT,IAAI,UAAU,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC;gBACH,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,CAAwB,CAAC;gBAC9F,UAAU,GAAG,KAAK,CAAC,KAAK,KAAK,UAAU,CAAC;YAC1C,CAAC;YAAC,MAAM,CAAC,CAAA,CAAC;YACV,IAAI,UAAU;gBAAE,MAAM,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAClF,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,IAAI,CAAC,SAAiB;QACjC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;QACjE,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IAC5E,CAAC;IAEM,KAAK,CAAC,IAAI,CACf,SAAiB,EACjB,MAA8B,EAC9B,gBAAwB;QAExB,OAAO,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,KAAK,IAAI,EAAE;YAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;YAC9C,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YACpD,MAAM,cAAc,GAAG,YAAY,KAAK,SAAS;gBAC/C,CAAC,CAAC,CAAC;gBACH,CAAC,CAAC,cAAc,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC;YACrD,IAAI,cAAc,KAAK,gBAAgB,EAAE,CAAC;gBACxC,MAAM,IAAI,4BAA4B,CAAC,SAAS,EAAE,gBAAgB,EAAE,cAAc,CAAC,CAAC;YACtF,CAAC;YACD,MAAM,QAAQ,GAAG,gBAAgB,GAAG,CAAC,CAAC;YACtC,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,cAAc,CAAC,SAAS,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;YAC9E,OAAO,QAAQ,CAAC;QAClB,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,OAA6B;QAChD,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QACnC,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,IAAI,EAAE;YACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;YACxE,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YACpD,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;gBAC/B,MAAM,OAAO,GAAG,aAAa,CAAC,YAAY,EAAE,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;gBAClF,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACtE,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACvE,IAAI,UAAU,KAAK,OAAO,EAAE,CAAC;oBAC3B,MAAM,IAAI,KAAK,CAAC,YAAY,OAAO,CAAC,SAAS,yCAAyC,CAAC,CAAC;gBAC1F,CAAC;gBACD,OAAO;YACT,CAAC;YACD,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,WAAW,CACtB,SAAiB,EACjB,SAAiB;QAEjB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;QAC3E,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;IACtF,CAAC;CACF"}

package/dist_ts_agent/plugins.d.ts

@@ -1,10 +1,3 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import * as crypto from 'node:crypto';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { isDeepStrictEqual } from 'node:util';
-import * as v8 from 'node:v8';
-export { AsyncLocalStorage, crypto, fs, isDeepStrictEqual, path, v8 };
 import { streamText, generateText, stepCountIs, wrapLanguageModel } from 'ai';
 export { streamText, generateText, stepCountIs, wrapLanguageModel };
 export type { AssistantModelMessage, ModelMessage, StepResult, SystemModelMessage, ToolSet, ToolModelMessage, ToolExecutionOptions, StreamTextResult, UserModelMessage, } from 'ai';

package/dist_ts_agent/plugins.js

@@ -1,11 +1,3 @@
-// node native
-import { AsyncLocalStorage } from 'node:async_hooks';
-import * as crypto from 'node:crypto';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { isDeepStrictEqual } from 'node:util';
-import * as v8 from 'node:v8';
-export { AsyncLocalStorage, crypto, fs, isDeepStrictEqual, path, v8 };
 // ai-sdk core
 import { streamText, generateText, stepCountIs, wrapLanguageModel } from 'ai';
 export { streamText, generateText, stepCountIs, wrapLanguageModel };
@@ -15,4 +7,4 @@ export { applySmartAiCacheProviderOptions, createSmartAiCachingMiddleware, resol
 // zod
 import { z } from 'zod';
 export { z };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2FnZW50L3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3JELE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDdkMsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFDbEMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQzlDLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBRTlCLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLEVBQUUsRUFBRSxFQUFFLGlCQUFpQixFQUFFLElBQUksRUFBRSxFQUFFLEVBQUUsQ0FBQztBQUV0RSxjQUFjO0FBQ2QsT0FBTyxFQUFFLFVBQVUsRUFBRSxZQUFZLEVBQUUsV0FBVyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sSUFBSSxDQUFDO0FBRTlFLE9BQU8sRUFBRSxVQUFVLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBRSxpQkFBaUIsRUFBRSxDQUFDO0FBY3BFLDZCQUE2QjtBQUM3QixPQUFPLEVBQ0wsZ0NBQWdDLEVBQ2hDLDhCQUE4QixFQUM5QixVQUFVLEVBQ1YsMkJBQTJCLEVBQzNCLElBQUksR0FDTCxNQUFNLHNDQUFzQyxDQUFDO0FBRTlDLE9BQU8sRUFDTCxnQ0FBZ0MsRUFDaEMsOEJBQThCLEVBQzlCLDJCQUEyQixFQUMzQixJQUFJLEVBQ0osVUFBVSxHQUNYLENBQUM7QUFnQkYsTUFBTTtBQUNOLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsT0FBTyxFQUFFLENBQUMsRUFBRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2FnZW50L3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sRUFBRSxVQUFVLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLElBQUksQ0FBQztBQUU5RSxPQUFPLEVBQUUsVUFBVSxFQUFFLFlBQVksRUFBRSxXQUFXLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQztBQWNwRSw2QkFBNkI7QUFDN0IsT0FBTyxFQUNMLGdDQUFnQyxFQUNoQyw4QkFBOEIsRUFDOUIsVUFBVSxFQUNWLDJCQUEyQixFQUMzQixJQUFJLEdBQ0wsTUFBTSxzQ0FBc0MsQ0FBQztBQUU5QyxPQUFPLEVBQ0wsZ0NBQWdDLEVBQ2hDLDhCQUE4QixFQUM5QiwyQkFBMkIsRUFDM0IsSUFBSSxFQUNKLFVBQVUsR0FDWCxDQUFDO0FBZ0JGLE1BQU07QUFDTixPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBRXhCLE9BQU8sRUFBRSxDQUFDLEVBQUUsQ0FBQyJ9

package/dist_ts_agent/plugins.node.d.ts

@@ -0,0 +1,7 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import * as v8 from 'node:v8';
+export { AsyncLocalStorage, crypto, fs, isDeepStrictEqual, path, v8 };

package/dist_ts_agent/plugins.node.js

@@ -0,0 +1,9 @@
+// node native
+import { AsyncLocalStorage } from 'node:async_hooks';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import * as v8 from 'node:v8';
+export { AsyncLocalStorage, crypto, fs, isDeepStrictEqual, path, v8 };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5ub2RlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfYWdlbnQvcGx1Z2lucy5ub2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWM7QUFDZCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUN0QyxPQUFPLEtBQUssRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3ZDLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUM5QyxPQUFPLEtBQUssRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUU5QixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxpQkFBaUIsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLENBQUMifQ==

package/dist_ts_agent/plugins.portable.d.ts

@@ -0,0 +1,4 @@
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';
+import { strictCircularDeepEqual } from 'fast-equals';
+export { sha256, bytesToHex, utf8ToBytes, strictCircularDeepEqual };

package/dist_ts_agent/plugins.portable.js

@@ -0,0 +1,5 @@
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';
+import { strictCircularDeepEqual } from 'fast-equals';
+export { sha256, bytesToHex, utf8ToBytes, strictCircularDeepEqual };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5wb3J0YWJsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2FnZW50L3BsdWdpbnMucG9ydGFibGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQy9DLE9BQU8sRUFBRSxVQUFVLEVBQUUsV0FBVyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDakUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRXRELE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSx1QkFBdUIsRUFBRSxDQUFDIn0=

package/dist_ts_agent/runner.d.ts

@@ -0,0 +1,4 @@
+import type { IAgentRunOptions, IAgentRunResult } from './smartagent.interfaces.js';
+/** Run in Node or a secure browser context, with internally owned cleanup. */
+export declare function runAgent(options: IAgentRunOptions): Promise<IAgentRunResult>;
+export type { IAgentRunOptions, IAgentRunResult } from './smartagent.interfaces.js';

package/dist_ts_agent/runner.js

@@ -0,0 +1,34 @@
+import * as plugins from './plugins.portable.js';
+import { AgentSessionEngine } from './classes.sessionengine.js';
+import { runAgentWithSession } from './runtime.run.js';
+const portablePlatform = {
+    createClaimToken: () => btoa(String.fromCharCode(...globalThis.crypto.getRandomValues(new Uint8Array(32))))
+        .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, ''),
+    hashClaimToken: (token) => plugins.bytesToHex(plugins.sha256(plugins.utf8ToBytes(token))),
+    equalClaimDigests: (left, right) => {
+        if (left.length !== right.length)
+            return false;
+        let difference = 0;
+        for (let index = 0; index < left.length; index++) {
+            difference |= left.charCodeAt(index) ^ right.charCodeAt(index);
+        }
+        return difference === 0;
+    },
+    isDeepEqual: plugins.strictCircularDeepEqual,
+    reportListenerError: (error) => console.warn('FLEXHARNESS_SESSION_LISTENER_ERROR', error),
+};
+// This class and its factory are deliberately not exported. Callbacks receive
+// data only; no caller can close this session from inside its active callback.
+class RunnerSession extends AgentSessionEngine {
+    constructor(options) {
+        super(options, portablePlatform, { kind: 'encapsulated' });
+    }
+    static create(options) {
+        return this.createWithFactory(options, () => new RunnerSession(options));
+    }
+}
+/** Run in Node or a secure browser context, with internally owned cleanup. */
+export function runAgent(options) {
+    return runAgentWithSession(options, (sessionOptions) => RunnerSession.create(sessionOptions));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_agent/runtime.interfaces.d.ts

@@ -0,0 +1,21 @@
+/** Internal platform boundary; only the documented agent entrypoints are exported. */
+export interface IAgentCallbackState {
+    active: boolean;
+}
+export interface IAgentCallbackScope {
+    getStore(): IAgentCallbackState | undefined;
+    run<TValue>(state: IAgentCallbackState, callback: () => TValue): TValue;
+}
+export type TAgentSessionOwnership = {
+    kind: 'exposed';
+    callbackScope: IAgentCallbackScope;
+} | {
+    kind: 'encapsulated';
+};
+export interface IAgentRuntimePlatform {
+    createClaimToken(): string;
+    hashClaimToken(token: string): string;
+    equalClaimDigests(left: string, right: string): boolean;
+    isDeepEqual(left: unknown, right: unknown): boolean;
+    reportListenerError(error: unknown): void;
+}

package/dist_ts_agent/runtime.interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVudGltZS5pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfYWdlbnQvcnVudGltZS5pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist_ts_agent/runtime.run.d.ts

@@ -0,0 +1,3 @@
+import type { IAgentSession, IAgentSessionOptions } from './smartagent.interfaces.js';
+import type { IAgentRunOptions, IAgentRunResult } from './smartagent.interfaces.js';
+export declare function runAgentWithSession(options: IAgentRunOptions, createSession: (options: IAgentSessionOptions) => Promise<IAgentSession>): Promise<IAgentRunResult>;

package/dist_ts_agent/runtime.run.js

@@ -0,0 +1,94 @@
+const mergeToolCalls = (target, source) => {
+    const indexes = new Map(target.map((record, index) => [record.toolCallId, index]));
+    for (const record of source) {
+        const existingIndex = indexes.get(record.toolCallId);
+        if (existingIndex === undefined) {
+            target.push({ ...record });
+            indexes.set(record.toolCallId, target.length - 1);
+        }
+        else {
+            target[existingIndex] = { ...target[existingIndex], ...record };
+        }
+    }
+};
+export async function runAgentWithSession(options, createSession) {
+    const session = await createSession({
+        model: options.model,
+        system: options.system,
+        tools: options.tools,
+        providerOptions: options.providerOptions,
+        sessionId: options.sessionId,
+        eventStore: options.eventStore,
+        cache: options.cache,
+        maxSteps: options.maxSteps,
+        messages: options.messages,
+        events: options.events,
+        executionContext: options.executionContext,
+        contextBuilder: options.contextBuilder,
+        contextCompactor: options.contextCompactor,
+        eventRetention: options.eventRetention,
+        changeListenerTimeoutMs: options.changeListenerTimeoutMs,
+        maxPendingSessionChanges: options.maxPendingSessionChanges,
+        generationLeaseCleanupTimeoutMs: options.generationLeaseCleanupTimeoutMs,
+        maxArchivedTransactionTombstones: options.maxArchivedTransactionTombstones,
+        onToken: options.onToken,
+        onReasoningStart: options.onReasoningStart,
+        onReasoningDelta: options.onReasoningDelta,
+        onReasoningEnd: options.onReasoningEnd,
+        onToolCallStart: options.onToolCallStart,
+        onToolCallUpdate: options.onToolCallUpdate,
+        onToolCallFinish: options.onToolCallFinish,
+        onToolCall: options.onToolCall,
+        onToolResult: options.onToolResult,
+        onContextOverflow: options.onContextOverflow,
+        maxContextOverflowRetries: options.maxContextOverflowRetries,
+    });
+    let totalSteps = 0;
+    let totalInput = 0;
+    let totalOutput = 0;
+    let totalCacheRead = 0;
+    let totalCacheWrite = 0;
+    let validationRetries = 0;
+    const toolCalls = [];
+    try {
+        await session.pushUserMessage(options.prompt);
+        while (true) {
+            const generationResult = await session.generate({
+                maxSteps: options.maxSteps,
+                abort: options.abort,
+            });
+            totalSteps += generationResult.steps;
+            totalInput += generationResult.usage.inputTokens;
+            totalOutput += generationResult.usage.outputTokens;
+            totalCacheRead += generationResult.usage.cacheReadTokens;
+            totalCacheWrite += generationResult.usage.cacheWriteTokens;
+            mergeToolCalls(toolCalls, generationResult.toolCalls);
+            const runResult = {
+                text: generationResult.text,
+                messages: session.getModelMessages(),
+                steps: totalSteps,
+                finishReason: generationResult.finishReason,
+                usage: {
+                    inputTokens: totalInput,
+                    outputTokens: totalOutput,
+                    totalTokens: totalInput + totalOutput,
+                    cacheReadTokens: totalCacheRead,
+                    cacheWriteTokens: totalCacheWrite,
+                },
+                toolCalls,
+            };
+            const validationPrompt = await options.validateCompletion?.(runResult);
+            if (typeof validationPrompt !== 'string')
+                return runResult;
+            if (validationRetries >= (options.maxValidationRetries ?? 0)) {
+                throw new Error(`Agent completion validation failed: ${validationPrompt}`);
+            }
+            validationRetries++;
+            await session.pushUserMessage(validationPrompt);
+        }
+    }
+    finally {
+        await session.close();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_agent/smartagent.classes.agent.js

@@ -1,95 +1,6 @@
 import { AgentSession } from './smartagent.classes.session.js';
-const mergeToolCalls = (target, source) => {
-    const indexes = new Map(target.map((record, index) => [record.toolCallId, index]));
-    for (const record of source) {
-        const existingIndex = indexes.get(record.toolCallId);
-        if (existingIndex === undefined) {
-            target.push({ ...record });
-            indexes.set(record.toolCallId, target.length - 1);
-        }
-        else {
-            target[existingIndex] = { ...target[existingIndex], ...record };
-        }
-    }
-};
-export async function runAgent(options) {
-    const session = await AgentSession.create({
-        model: options.model,
-        system: options.system,
-        tools: options.tools,
-        providerOptions: options.providerOptions,
-        sessionId: options.sessionId,
-        eventStore: options.eventStore,
-        cache: options.cache,
-        maxSteps: options.maxSteps,
-        messages: options.messages,
-        events: options.events,
-        executionContext: options.executionContext,
-        contextBuilder: options.contextBuilder,
-        contextCompactor: options.contextCompactor,
-        eventRetention: options.eventRetention,
-        changeListenerTimeoutMs: options.changeListenerTimeoutMs,
-        maxPendingSessionChanges: options.maxPendingSessionChanges,
-        generationLeaseCleanupTimeoutMs: options.generationLeaseCleanupTimeoutMs,
-        maxArchivedTransactionTombstones: options.maxArchivedTransactionTombstones,
-        onToken: options.onToken,
-        onReasoningStart: options.onReasoningStart,
-        onReasoningDelta: options.onReasoningDelta,
-        onReasoningEnd: options.onReasoningEnd,
-        onToolCallStart: options.onToolCallStart,
-        onToolCallUpdate: options.onToolCallUpdate,
-        onToolCallFinish: options.onToolCallFinish,
-        onToolCall: options.onToolCall,
-        onToolResult: options.onToolResult,
-        onContextOverflow: options.onContextOverflow,
-        maxContextOverflowRetries: options.maxContextOverflowRetries,
-    });
-    let totalSteps = 0;
-    let totalInput = 0;
-    let totalOutput = 0;
-    let totalCacheRead = 0;
-    let totalCacheWrite = 0;
-    let validationRetries = 0;
-    const toolCalls = [];
-    try {
-        await session.pushUserMessage(options.prompt);
-        while (true) {
-            const generationResult = await session.generate({
-                maxSteps: options.maxSteps,
-                abort: options.abort,
-            });
-            totalSteps += generationResult.steps;
-            totalInput += generationResult.usage.inputTokens;
-            totalOutput += generationResult.usage.outputTokens;
-            totalCacheRead += generationResult.usage.cacheReadTokens;
-            totalCacheWrite += generationResult.usage.cacheWriteTokens;
-            mergeToolCalls(toolCalls, generationResult.toolCalls);
-            const runResult = {
-                text: generationResult.text,
-                messages: session.getModelMessages(),
-                steps: totalSteps,
-                finishReason: generationResult.finishReason,
-                usage: {
-                    inputTokens: totalInput,
-                    outputTokens: totalOutput,
-                    totalTokens: totalInput + totalOutput,
-                    cacheReadTokens: totalCacheRead,
-                    cacheWriteTokens: totalCacheWrite,
-                },
-                toolCalls,
-            };
-            const validationPrompt = await options.validateCompletion?.(runResult);
-            if (typeof validationPrompt !== 'string')
-                return runResult;
-            if (validationRetries >= (options.maxValidationRetries ?? 0)) {
-                throw new Error(`Agent completion validation failed: ${validationPrompt}`);
-            }
-            validationRetries++;
-            await session.pushUserMessage(validationPrompt);
-        }
-    }
-    finally {
-        await session.close();
-    }
+import { runAgentWithSession } from './runtime.run.js';
+export function runAgent(options) {
+    return runAgentWithSession(options, (sessionOptions) => AgentSession.create(sessionOptions));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhZ2VudC5jbGFzc2VzLmFnZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfYWdlbnQvc21hcnRhZ2VudC5jbGFzc2VzLmFnZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUMvRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUd2RCxNQUFNLFVBQVUsUUFBUSxDQUFDLE9BQXlCO0lBQ2hELE9BQU8sbUJBQW1CLENBQUMsT0FBTyxFQUFFLENBQUMsY0FBYyxFQUFFLEVBQUUsQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUM7QUFDL0YsQ0FBQyJ9