@modelprofile.com/flexharness 1.0.0

package/dist_ts/classes.stores.d.ts

@@ -0,0 +1,26 @@
+import type { IFlexHarnessSnapshot, IFlexHarnessStore } from './interfaces.js';
+export declare class InMemoryFlexHarnessStore implements IFlexHarnessStore {
+    private readonly snapshots;
+    load(storageKey: string): Promise<IFlexHarnessSnapshot | undefined>;
+    save(storageKey: string, snapshot: IFlexHarnessSnapshot, expectedRevision: number): Promise<void>;
+}
+export interface IJsonFileFlexHarnessStoreOptions {
+    directory: string;
+}
+/**
+ * Atomic and CAS-safe across instances in this process. It intentionally does not
+ * claim cross-process safety because no operating-system lock is held.
+ */
+export declare class JsonFileFlexHarnessStore implements IFlexHarnessStore {
+    private static readonly fileQueues;
+    private readonly directory;
+    constructor(options: IJsonFileFlexHarnessStoreOptions);
+    load(storageKey: string): Promise<IFlexHarnessSnapshot | undefined>;
+    save(storageKey: string, snapshot: IFlexHarnessSnapshot, expectedRevision: number): Promise<void>;
+    private static inFileQueue;
+    private filePath;
+    private preparePath;
+    private cleanupTemps;
+    private readSnapshot;
+    private writeSnapshot;
+}

package/dist_ts/classes.stores.js

@@ -0,0 +1,156 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessStoreConflictError, FlexHarnessStoreFormatError, FlexHarnessValidationError, } from './errors.js';
+import { assertFlexHarnessSnapshot, cloneSerializable } from './utils.json.js';
+function validateSave(snapshot, expectedRevision) {
+    assertFlexHarnessSnapshot(snapshot);
+    if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) {
+        throw new FlexHarnessValidationError('expectedRevision must be a non-negative integer.');
+    }
+    if (snapshot.revision !== expectedRevision + 1) {
+        throw new FlexHarnessStoreFormatError(`Snapshot revision ${snapshot.revision} must equal expected revision ${expectedRevision} plus one.`);
+    }
+    return cloneSerializable(snapshot);
+}
+export class InMemoryFlexHarnessStore {
+    snapshots = new Map();
+    async load(storageKey) {
+        const snapshot = this.snapshots.get(storageKey);
+        return snapshot ? cloneSerializable(snapshot) : undefined;
+    }
+    async save(storageKey, snapshot, expectedRevision) {
+        const validated = validateSave(snapshot, expectedRevision);
+        const actualRevision = this.snapshots.get(storageKey)?.revision ?? 0;
+        if (actualRevision !== expectedRevision) {
+            throw new FlexHarnessStoreConflictError(storageKey, expectedRevision, actualRevision);
+        }
+        this.snapshots.set(storageKey, validated);
+    }
+}
+/**
+ * Atomic and CAS-safe across instances in this process. It intentionally does not
+ * claim cross-process safety because no operating-system lock is held.
+ */
+export class JsonFileFlexHarnessStore {
+    static fileQueues = new Map();
+    directory;
+    constructor(options) {
+        if (!options.directory) {
+            throw new FlexHarnessValidationError('JsonFileFlexHarnessStore requires a directory.');
+        }
+        this.directory = plugins.path.resolve(options.directory);
+    }
+    async load(storageKey) {
+        const filePath = this.filePath(storageKey);
+        return JsonFileFlexHarnessStore.inFileQueue(filePath, async () => {
+            await this.preparePath(filePath);
+            return this.readSnapshot(filePath);
+        });
+    }
+    async save(storageKey, snapshot, expectedRevision) {
+        const validated = validateSave(snapshot, expectedRevision);
+        const filePath = this.filePath(storageKey);
+        await JsonFileFlexHarnessStore.inFileQueue(filePath, async () => {
+            await this.preparePath(filePath);
+            const current = await this.readSnapshot(filePath);
+            const actualRevision = current?.revision ?? 0;
+            if (actualRevision !== expectedRevision) {
+                throw new FlexHarnessStoreConflictError(storageKey, expectedRevision, actualRevision);
+            }
+            await this.writeSnapshot(filePath, validated);
+        });
+    }
+    static inFileQueue(filePath, operation) {
+        const previous = JsonFileFlexHarnessStore.fileQueues.get(filePath) ?? Promise.resolve();
+        const result = previous.catch(() => undefined).then(operation);
+        const barrier = result.then(() => undefined, () => undefined);
+        JsonFileFlexHarnessStore.fileQueues.set(filePath, barrier);
+        void barrier.then(() => {
+            if (JsonFileFlexHarnessStore.fileQueues.get(filePath) === barrier) {
+                JsonFileFlexHarnessStore.fileQueues.delete(filePath);
+            }
+        });
+        return result;
+    }
+    filePath(storageKey) {
+        const digest = plugins.crypto.createHash('sha256').update(storageKey).digest('hex');
+        return plugins.path.join(this.directory, `${digest}.json`);
+    }
+    async preparePath(filePath) {
+        await plugins.fs.mkdir(this.directory, { recursive: true, mode: 0o700 });
+        await plugins.fs.chmod(this.directory, 0o700);
+        await this.cleanupTemps(filePath);
+    }
+    async cleanupTemps(filePath) {
+        const prefix = `${plugins.path.basename(filePath)}.`;
+        const entries = await plugins.fs.readdir(this.directory, { withFileTypes: true });
+        await Promise.all(entries
+            .filter((entry) => entry.isFile() && entry.name.startsWith(prefix) && entry.name.endsWith('.tmp'))
+            .map(async (entry) => {
+            try {
+                await plugins.fs.unlink(plugins.path.join(this.directory, entry.name));
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+        }));
+    }
+    async readSnapshot(filePath) {
+        let serialized;
+        try {
+            await plugins.fs.chmod(filePath, 0o600);
+            serialized = await plugins.fs.readFile(filePath, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return undefined;
+            }
+            throw error;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(serialized);
+        }
+        catch (error) {
+            throw new FlexHarnessStoreFormatError(`Malformed JSON snapshot at ${filePath}.`, {
+                cause: error,
+            });
+        }
+        try {
+            assertFlexHarnessSnapshot(parsed);
+        }
+        catch (error) {
+            if (error instanceof FlexHarnessStoreFormatError) {
+                throw new FlexHarnessStoreFormatError(`Invalid snapshot at ${filePath}: ${error.message}`, {
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+        return cloneSerializable(parsed);
+    }
+    async writeSnapshot(filePath, snapshot) {
+        const tempPath = `${filePath}.${process.pid}.${plugins.crypto.randomUUID()}.tmp`;
+        let fileHandle;
+        try {
+            fileHandle = await plugins.fs.open(tempPath, 'wx', 0o600);
+            await fileHandle.writeFile(`${JSON.stringify(snapshot, null, 2)}\n`, 'utf8');
+            await fileHandle.sync();
+            await fileHandle.close();
+            fileHandle = undefined;
+            await plugins.fs.chmod(tempPath, 0o600);
+            await plugins.fs.rename(tempPath, filePath);
+            await plugins.fs.chmod(filePath, 0o600);
+        }
+        finally {
+            await fileHandle?.close().catch(() => undefined);
+            await plugins.fs.unlink(tempPath).catch((error) => {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stores.js","sourceRoot":"","sources":["../ts/classes.stores.ts"],"names":[],"mappings":"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"}

package/dist_ts/errors.d.ts

@@ -0,0 +1,44 @@
+import type { IFlexErrorInfo } from './interfaces.js';
+export declare class FlexHarnessError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string, options?: ErrorOptions);
+}
+export declare class FlexHarnessValidationError extends FlexHarnessError {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class FlexHarnessClosedError extends FlexHarnessError {
+    constructor();
+}
+export declare class FlexHarnessNotFoundError extends FlexHarnessError {
+    constructor(resource: string, id: string);
+}
+export declare class FlexHarnessSessionBusyError extends FlexHarnessError {
+    constructor(sessionId: string, reason?: string);
+}
+export declare class FlexHarnessAbortError extends FlexHarnessError {
+    constructor(message?: string, options?: ErrorOptions);
+}
+export declare class FlexHarnessCallbackOverflowError extends FlexHarnessError {
+    constructor(message: string);
+}
+export declare class FlexHarnessPermissionRejectedError extends FlexHarnessError {
+    constructor(permissionId: string, options?: ErrorOptions);
+}
+export declare class FlexHarnessPermissionStateError extends FlexHarnessError {
+    constructor(message: string);
+}
+export declare class FlexHarnessStoreConflictError extends FlexHarnessError {
+    readonly storageKey: string;
+    readonly expectedRevision: number;
+    readonly actualRevision: number;
+    constructor(storageKey: string, expectedRevision: number, actualRevision: number);
+}
+export declare class FlexHarnessStoreFormatError extends FlexHarnessError {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class FlexHarnessRunError extends AggregateError {
+    readonly code = "FLEX_RUN_FAILED";
+    constructor(errors: unknown[]);
+}
+export declare function errorToInfo(error: unknown): IFlexErrorInfo;
+export declare function errorMessage(error: unknown): string;

package/dist_ts/errors.js

@@ -0,0 +1,105 @@
+export class FlexHarnessError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = 'FlexHarnessError';
+        this.code = code;
+    }
+}
+export class FlexHarnessValidationError extends FlexHarnessError {
+    constructor(message, options) {
+        super('FLEX_VALIDATION', message, options);
+        this.name = 'FlexHarnessValidationError';
+    }
+}
+export class FlexHarnessClosedError extends FlexHarnessError {
+    constructor() {
+        super('FLEX_CLOSED', 'FlexHarness is disposed.');
+        this.name = 'FlexHarnessClosedError';
+    }
+}
+export class FlexHarnessNotFoundError extends FlexHarnessError {
+    constructor(resource, id) {
+        super('FLEX_NOT_FOUND', `${resource} "${id}" was not found.`);
+        this.name = 'FlexHarnessNotFoundError';
+    }
+}
+export class FlexHarnessSessionBusyError extends FlexHarnessError {
+    constructor(sessionId, reason = 'already has an active run') {
+        super('FLEX_SESSION_BUSY', `Session "${sessionId}" ${reason}.`);
+        this.name = 'FlexHarnessSessionBusyError';
+    }
+}
+export class FlexHarnessAbortError extends FlexHarnessError {
+    constructor(message = 'The run was aborted.', options) {
+        super('FLEX_ABORTED', message, options);
+        this.name = 'FlexHarnessAbortError';
+    }
+}
+export class FlexHarnessCallbackOverflowError extends FlexHarnessError {
+    constructor(message) {
+        super('FLEX_CALLBACK_OVERFLOW', message);
+        this.name = 'FlexHarnessCallbackOverflowError';
+    }
+}
+export class FlexHarnessPermissionRejectedError extends FlexHarnessError {
+    constructor(permissionId, options) {
+        super('FLEX_PERMISSION_REJECTED', `Permission "${permissionId}" was rejected.`, options);
+        this.name = 'FlexHarnessPermissionRejectedError';
+    }
+}
+export class FlexHarnessPermissionStateError extends FlexHarnessError {
+    constructor(message) {
+        super('FLEX_PERMISSION_STATE', message);
+        this.name = 'FlexHarnessPermissionStateError';
+    }
+}
+export class FlexHarnessStoreConflictError extends FlexHarnessError {
+    storageKey;
+    expectedRevision;
+    actualRevision;
+    constructor(storageKey, expectedRevision, actualRevision) {
+        super('FLEX_STORE_CONFLICT', `Snapshot conflict for storage key "${storageKey}": expected revision ${expectedRevision}, found ${actualRevision}.`);
+        this.name = 'FlexHarnessStoreConflictError';
+        this.storageKey = storageKey;
+        this.expectedRevision = expectedRevision;
+        this.actualRevision = actualRevision;
+    }
+}
+export class FlexHarnessStoreFormatError extends FlexHarnessError {
+    constructor(message, options) {
+        super('FLEX_STORE_FORMAT', message, options);
+        this.name = 'FlexHarnessStoreFormatError';
+    }
+}
+export class FlexHarnessRunError extends AggregateError {
+    code = 'FLEX_RUN_FAILED';
+    constructor(errors) {
+        super(errors, 'Multiple FlexHarness run or cleanup operations failed.');
+        this.name = 'FlexHarnessRunError';
+    }
+}
+export function errorToInfo(error) {
+    if (error instanceof FlexHarnessError) {
+        return {
+            name: error.name,
+            message: error.message,
+            code: error.code,
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            ...('code' in error && typeof error.code === 'string' ? { code: error.code } : {}),
+        };
+    }
+    return {
+        name: 'Error',
+        message: String(error),
+    };
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -0,0 +1,5 @@
+export * from './classes.flexharness.js';
+export * from './classes.stores.js';
+export * from './errors.js';
+export * from './interfaces.js';
+export { normalizeJsonValue } from './utils.json.js';

package/dist_ts/index.js

@@ -0,0 +1,6 @@
+export * from './classes.flexharness.js';
+export * from './classes.stores.js';
+export * from './errors.js';
+export * from './interfaces.js';
+export { normalizeJsonValue } from './utils.json.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQyJ9

package/dist_ts/interfaces.d.ts

@@ -0,0 +1,288 @@
+import type * as plugins from './plugins.js';
+export type TJsonPrimitive = string | number | boolean | null;
+export interface IJsonObject {
+    [key: string]: TJsonValue;
+}
+export type TJsonValue = TJsonPrimitive | IJsonObject | TJsonValue[];
+export type TFlexAgentRunOptions = plugins.IAgentRunOptions;
+export type TFlexAgentRunResult = plugins.IAgentRunResult;
+export type TFlexAgentRunner = (options: TFlexAgentRunOptions) => Promise<TFlexAgentRunResult>;
+export type TFlexAgentModel = TFlexAgentRunOptions['model'];
+export type TFlexAgentPrompt = TFlexAgentRunOptions['prompt'];
+export type TFlexAgentModelMessage = NonNullable<TFlexAgentRunOptions['messages']>[number];
+export type TFlexAgentToolSet = NonNullable<TFlexAgentRunOptions['tools']>;
+export type TFlexAgentProviderOptions = TFlexAgentRunOptions['providerOptions'];
+export type TFlexAgentCacheSetting = TFlexAgentRunOptions['cache'];
+export type TFlexAgentToolCallFinishEvent = Parameters<NonNullable<TFlexAgentRunOptions['onToolCallFinish']>>[0];
+export interface IFlexTextPromptPart {
+    type: 'text';
+    text: string;
+}
+export interface IFlexImagePromptPart {
+    type: 'image';
+    data: string;
+    mediaType?: string;
+    name?: string;
+}
+export interface IFlexFilePromptPart {
+    type: 'file';
+    data: string;
+    mediaType: string;
+    name?: string;
+}
+export type TFlexPromptPart = IFlexTextPromptPart | IFlexImagePromptPart | IFlexFilePromptPart;
+export type TFlexPrompt = string | TFlexPromptPart[];
+export interface IFlexUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+}
+export interface IFlexModelIdentity {
+    provider: string;
+    model: string;
+    displayName?: string;
+}
+export type TFlexActivityStatus = 'idle' | 'running' | 'waiting_permission' | 'failed' | 'cancelled';
+export type TFlexMessageStatus = 'streaming' | 'completed' | 'failed' | 'cancelled';
+export type TFlexToolPartStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+export type TFlexAttachmentSource = 'inline-base64' | 'data-url' | 'remote-url';
+export interface IFlexTextMessagePart {
+    partId: string;
+    type: 'text';
+    text: string;
+}
+export interface IFlexReasoningMessagePart {
+    partId: string;
+    type: 'reasoning';
+    text: string;
+    status: 'running' | 'completed' | 'cancelled';
+}
+export interface IFlexToolMessagePart {
+    partId: string;
+    type: 'tool';
+    toolCallId: string;
+    toolName: string;
+    status: TFlexToolPartStatus;
+    input: TJsonValue;
+    output?: TJsonValue;
+    error?: string;
+}
+export interface IFlexAttachmentMessagePart {
+    partId: string;
+    type: 'attachment';
+    attachmentType: 'image' | 'file';
+    source: TFlexAttachmentSource;
+    sizeBytes?: number;
+    mediaType?: string;
+    name?: string;
+}
+export type TFlexMessagePart = IFlexTextMessagePart | IFlexReasoningMessagePart | IFlexToolMessagePart | IFlexAttachmentMessagePart;
+export interface IFlexMessage {
+    messageId: string;
+    sessionId: string;
+    runId: string;
+    role: 'user' | 'assistant';
+    status: TFlexMessageStatus;
+    createdAt: string;
+    completedAt?: string;
+    parts: TFlexMessagePart[];
+    model?: IFlexModelIdentity;
+    usage?: IFlexUsage;
+    error?: string;
+}
+export interface IFlexSessionActivity {
+    runId?: string;
+    status: TFlexActivityStatus;
+    startedAt?: string;
+    completedAt?: string;
+    error?: string;
+}
+export interface IFlexSession {
+    scopeId: string;
+    sessionId: string;
+    title?: string;
+    createdAt: string;
+    updatedAt: string;
+    archivedAt?: string;
+    status: TFlexActivityStatus;
+    activity: IFlexSessionActivity;
+}
+export interface IFlexCreateSessionOptions {
+    sessionId?: string;
+    title?: string;
+}
+export interface IFlexUpdateSessionOptions {
+    title?: string | null;
+    archived?: boolean;
+}
+export interface IFlexPromptOptions {
+    modelHint?: string;
+    system?: string;
+    maxSteps?: number;
+}
+export interface IFlexPromptResult {
+    runId: string;
+    sessionId: string;
+    userMessage: IFlexMessage;
+    assistantMessage: IFlexMessage;
+    model: IFlexModelIdentity;
+    usage: IFlexUsage;
+    finishReason: string;
+    steps: number;
+}
+export interface IFlexResolvedScope<TScope> {
+    storageKey: string;
+    scope: TScope;
+}
+export interface IFlexScopeResolver<TScope> {
+    resolveScope(scopeId: string): Promise<IFlexResolvedScope<TScope>> | IFlexResolvedScope<TScope>;
+}
+export interface IFlexModelResolverContext<TScope> {
+    scopeId: string;
+    scope: TScope;
+    sessionId: string;
+    runId: string;
+    modelHint?: string;
+    signal: AbortSignal;
+}
+export interface IFlexResolvedModel {
+    model: TFlexAgentModel;
+    identity: IFlexModelIdentity;
+    system?: string;
+    providerOptions?: TFlexAgentProviderOptions;
+    cache?: TFlexAgentCacheSetting;
+    maxSteps?: number;
+}
+export interface IFlexModelResolver<TScope> {
+    resolveModel(context: IFlexModelResolverContext<TScope>): Promise<IFlexResolvedModel> | IFlexResolvedModel;
+}
+export interface IFlexPermissionRequestInput {
+    kind: string;
+    description: string;
+    toolCallId?: string;
+    rememberKey?: string;
+    metadata?: TJsonValue;
+}
+export interface IFlexPermissionRequest extends IFlexPermissionRequestInput {
+    permissionId: string;
+    scopeId: string;
+    sessionId: string;
+    runId: string;
+    createdAt: string;
+}
+export type TFlexPermissionDecision = 'once' | 'always' | 'reject';
+export interface IFlexToolProviderContext<TScope> {
+    scopeId: string;
+    scope: TScope;
+    sessionId: string;
+    runId: string;
+    signal: AbortSignal;
+    requestPermission(request: IFlexPermissionRequestInput): Promise<void>;
+}
+export interface IFlexToolHandle {
+    tools: TFlexAgentToolSet;
+    close?(): Promise<void> | void;
+}
+export interface IFlexToolProvider<TScope> {
+    provideTools(context: IFlexToolProviderContext<TScope>): Promise<IFlexToolHandle | undefined> | IFlexToolHandle | undefined;
+}
+export interface IFlexStoredSessionSnapshot {
+    session: IFlexSession;
+    messages: IFlexMessage[];
+    modelHistory: TJsonValue[];
+    rememberedPermissionKeys: string[];
+}
+export interface IFlexHarnessSnapshot {
+    schemaVersion: 1;
+    revision: number;
+    sessions: IFlexStoredSessionSnapshot[];
+}
+export interface IFlexHarnessStore {
+    load(storageKey: string): Promise<IFlexHarnessSnapshot | undefined>;
+    save(storageKey: string, snapshot: IFlexHarnessSnapshot, expectedRevision: number): Promise<void>;
+}
+export interface IFlexJsonLimits {
+    maxDepth?: number;
+    maxBytes?: number;
+}
+export interface IFlexCallbackLimits {
+    maxEvents?: number;
+    maxOutputBytes?: number;
+    maxParts?: number;
+}
+export interface IFlexHarnessOptions<TScope> {
+    scopeResolver: IFlexScopeResolver<TScope>;
+    modelResolver: IFlexModelResolver<TScope>;
+    toolProvider?: IFlexToolProvider<TScope>;
+    store?: IFlexHarnessStore;
+    runner?: TFlexAgentRunner;
+    toolOutputLimits?: IFlexJsonLimits;
+    callbackLimits?: IFlexCallbackLimits;
+}
+export interface IFlexEventBase {
+    readonly eventId: string;
+    readonly sequence: number;
+    readonly timestamp: string;
+    readonly scopeId: string;
+    readonly sessionId: string;
+}
+export interface IFlexSessionCreatedEvent extends IFlexEventBase {
+    readonly type: 'session.created';
+    readonly session: IFlexSession;
+}
+export interface IFlexSessionUpdatedEvent extends IFlexEventBase {
+    readonly type: 'session.updated';
+    readonly session: IFlexSession;
+}
+export interface IFlexSessionDeletedEvent extends IFlexEventBase {
+    readonly type: 'session.deleted';
+    readonly session: IFlexSession;
+}
+export interface IFlexRunStartedEvent extends IFlexEventBase {
+    readonly type: 'run.started';
+    readonly runId: string;
+    readonly messageId: string;
+    readonly session: IFlexSession;
+}
+export interface IFlexMessageChangedEvent extends IFlexEventBase {
+    readonly type: 'message.created' | 'message.updated';
+    readonly runId: string;
+    readonly messageId: string;
+    readonly message: IFlexMessage;
+}
+export interface IFlexPartChangedEvent extends IFlexEventBase {
+    readonly type: 'part.started' | 'part.delta' | 'part.completed';
+    readonly runId: string;
+    readonly messageId: string;
+    readonly partId: string;
+    readonly part: TFlexMessagePart;
+    readonly delta?: string;
+}
+export interface IFlexPermissionRequestedEvent extends IFlexEventBase {
+    readonly type: 'permission.requested';
+    readonly runId: string;
+    readonly request: IFlexPermissionRequest;
+}
+export interface IFlexPermissionResolvedEvent extends IFlexEventBase {
+    readonly type: 'permission.resolved';
+    readonly runId: string;
+    readonly request: IFlexPermissionRequest;
+    readonly decision: TFlexPermissionDecision;
+}
+export interface IFlexRunFinishedEvent extends IFlexEventBase {
+    readonly type: 'run.finished';
+    readonly runId: string;
+    readonly messageId: string;
+    readonly status: 'completed' | 'failed' | 'cancelled';
+    readonly message: IFlexMessage;
+    readonly error?: IFlexErrorInfo;
+}
+export interface IFlexErrorInfo {
+    name: string;
+    message: string;
+    code?: string;
+}
+export type TFlexHarnessEvent = IFlexSessionCreatedEvent | IFlexSessionUpdatedEvent | IFlexSessionDeletedEvent | IFlexRunStartedEvent | IFlexMessageChangedEvent | IFlexPartChangedEvent | IFlexPermissionRequestedEvent | IFlexPermissionResolvedEvent | IFlexRunFinishedEvent;
+export type TFlexHarnessEventListener = (event: TFlexHarnessEvent) => void;

package/dist_ts/interfaces.js

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

package/dist_ts/plugins.d.ts

@@ -0,0 +1,7 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+export { crypto, fs, path };
+import { runAgent } from '@push.rocks/smartagent';
+export { runAgent };
+export type { IAgentRunOptions, IAgentRunResult, } from '@push.rocks/smartagent';

package/dist_ts/plugins.js

@@ -0,0 +1,9 @@
+// node native scope
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+export { crypto, fs, path };
+// @push.rocks scope
+import { runAgent } from '@push.rocks/smartagent';
+export { runAgent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDdkMsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFFbEMsT0FBTyxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFFNUIsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUVsRCxPQUFPLEVBQUUsUUFBUSxFQUFFLENBQUMifQ==