@pellux/goodvibes-sdk 0.18.14 → 0.18.16

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge.d.ts

@@ -0,0 +1,67 @@
+/**
+ * DomainBridge — bridges RuntimeEventBus events to OTel span creation.
+ *
+ * Subscribes to all domain channels on the RuntimeEventBus and routes
+ * lifecycle events to the appropriate span helper functions. Maintains
+ * an active span map keyed by entity ID so that start events open spans
+ * and terminal events close them with outcome context.
+ *
+ * Design principles:
+ * - Span creation is purely observational — bridge failures must not
+ *   affect the domain logic that emits events.
+ * - All map lookups are safe — missing spans on terminal events are no-ops.
+ * - The bridge is opt-in: calling `attach()` wires it; `detach()` unwires.
+ */
+import type { RuntimeEventBus } from '../../events/index.js';
+import type { RuntimeTracer } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/tracer';
+import type { CascadeAppliedEvent } from '@pellux/goodvibes-sdk/platform/runtime/health/types';
+/**
+ * DomainBridge wires the RuntimeEventBus to the OTel span system.
+ *
+ * Usage:
+ * ```ts
+ * const bridge = new DomainBridge(tracer);
+ * const detach = bridge.attach(bus);
+ * // later:
+ * detach();
+ * ```
+ */
+export declare class DomainBridge {
+    private readonly _tracer;
+    /** Active spans per domain, keyed by entity ID. */
+    private readonly _pluginSpans;
+    private readonly _mcpSpans;
+    private readonly _transportSpans;
+    private readonly _taskSpans;
+    private readonly _agentSpans;
+    private readonly _permissionSpans;
+    private readonly _sessionSpans;
+    private readonly _compactionSpans;
+    constructor(tracer: RuntimeTracer);
+    /**
+     * Attach the bridge to the given event bus.
+     *
+     * Subscribes to all domain channels. Returns a cleanup function that
+     * unsubscribes all listeners when called.
+     *
+     * @param bus - The RuntimeEventBus to subscribe to.
+     * @returns A `detach` function that unsubscribes all domain listeners.
+     */
+    attach(bus: RuntimeEventBus): () => void;
+    /**
+     * Record a health cascade event as a point-in-time span.
+     *
+     * Called by the caller when CASCADE_APPLIED events are produced by the
+     * CascadeEngine. The caller is responsible for providing the trace ID
+     * from their current operational context.
+     *
+     * @param event - The CASCADE_APPLIED event.
+     * @param traceId - Trace ID to use for correlation.
+     */
+    recordCascade(event: CascadeAppliedEvent, traceId: string): void;
+    private _safe;
+    private _withSpan;
+    private _closeSpan;
+    private _helpers;
+}
+//# sourceMappingURL=domain-bridge.d.ts.map

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-bridge.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/telemetry/instrumentation/domain-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yDAAyD,CAAC;AAE7F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAO/F;;;;;;;;;;GAUG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IAExC,mDAAmD;IACnD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsB;IACnD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAChD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAsB;IACtD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsB;IAClD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsB;IACvD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAsB;IACpD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsB;gBAE3C,MAAM,EAAE,aAAa;IAIjC;;;;;;;;OAQG;IACI,MAAM,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,IAAI;IAoB/C;;;;;;;;;OASG;IACI,aAAa,CAAC,KAAK,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAMvE,OAAO,CAAC,KAAK;IAQb,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,QAAQ;CAQjB"}

package/dist/_internal/platform/runtime/telemetry/instrumentation/domain-bridge.js

@@ -0,0 +1,101 @@
+import { recordHealthCascadeSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/health';
+import { attachAgentDomain, attachCompactionDomain, attachPermissionDomain, attachSessionDomain } from './domain-bridge-agent-session.js';
+import { attachPluginDomain, attachMcpDomain } from './domain-bridge-plugin-mcp.js';
+import {} from './domain-bridge-shared.js';
+import { attachTaskDomain, attachTransportDomain } from './domain-bridge-transport-task.js';
+/**
+ * DomainBridge wires the RuntimeEventBus to the OTel span system.
+ *
+ * Usage:
+ * ```ts
+ * const bridge = new DomainBridge(tracer);
+ * const detach = bridge.attach(bus);
+ * // later:
+ * detach();
+ * ```
+ */
+export class DomainBridge {
+    _tracer;
+    /** Active spans per domain, keyed by entity ID. */
+    _pluginSpans = new Map();
+    _mcpSpans = new Map();
+    _transportSpans = new Map();
+    _taskSpans = new Map();
+    _agentSpans = new Map();
+    _permissionSpans = new Map();
+    _sessionSpans = new Map();
+    _compactionSpans = new Map();
+    constructor(tracer) {
+        this._tracer = tracer;
+    }
+    /**
+     * Attach the bridge to the given event bus.
+     *
+     * Subscribes to all domain channels. Returns a cleanup function that
+     * unsubscribes all listeners when called.
+     *
+     * @param bus - The RuntimeEventBus to subscribe to.
+     * @returns A `detach` function that unsubscribes all domain listeners.
+     */
+    attach(bus) {
+        const helpers = this._helpers();
+        const unsubs = [
+            attachPluginDomain({ bus, helpers }, this._pluginSpans),
+            attachMcpDomain({ bus, helpers }, this._mcpSpans),
+            attachTransportDomain({ bus, helpers }, this._transportSpans),
+            attachTaskDomain({ bus, helpers }, this._taskSpans),
+            attachAgentDomain({ bus, helpers }, this._agentSpans),
+            attachPermissionDomain({ bus, helpers }, this._permissionSpans),
+            attachSessionDomain({ bus, helpers }, this._sessionSpans),
+            attachCompactionDomain({ bus, helpers }, this._compactionSpans),
+        ];
+        return () => {
+            for (const unsub of unsubs) {
+                unsub();
+            }
+        };
+    }
+    /**
+     * Record a health cascade event as a point-in-time span.
+     *
+     * Called by the caller when CASCADE_APPLIED events are produced by the
+     * CascadeEngine. The caller is responsible for providing the trace ID
+     * from their current operational context.
+     *
+     * @param event - The CASCADE_APPLIED event.
+     * @param traceId - Trace ID to use for correlation.
+     */
+    recordCascade(event, traceId) {
+        this._safe(() => {
+            recordHealthCascadeSpan(this._tracer, event, { traceId });
+        });
+    }
+    _safe(action) {
+        try {
+            action();
+        }
+        catch {
+            // Bridge failure must not propagate — non-fatal, swallowed intentionally
+        }
+    }
+    _withSpan(map, key, action) {
+        const span = map.get(key);
+        if (span)
+            action(span);
+    }
+    _closeSpan(map, key, action) {
+        const span = map.get(key);
+        if (!span)
+            return;
+        action(span);
+        map.delete(key);
+    }
+    _helpers() {
+        return {
+            tracer: this._tracer,
+            safe: (action) => this._safe(action),
+            withSpan: (map, key, action) => this._withSpan(map, key, action),
+            closeSpan: (map, key, action) => this._closeSpan(map, key, action),
+        };
+    }
+}

package/dist/_internal/platform/runtime/telemetry/instrumentation/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Telemetry instrumentation — barrel and factory.
+ *
+ * Provides `createInstrumentation()` which wires the DomainBridge to
+ * a RuntimeEventBus and returns a handle for detaching and cascade recording.
+ *
+ * @example
+ * ```ts
+ * import { createInstrumentation } from './instrumentation/index.js';
+ *
+ * const { detach, recordCascade } = createInstrumentation(tracer, bus);
+ *
+ * // When a cascade fires:
+ * recordCascade(cascadeAppliedEvent, currentTraceId);
+ *
+ * // On shutdown:
+ * detach();
+ * ```
+ */
+import type { RuntimeTracer } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/tracer';
+import type { RuntimeEventBus } from '../../events/index.js';
+import type { CascadeAppliedEvent } from '@pellux/goodvibes-sdk/platform/runtime/health/types';
+export { DomainBridge } from './domain-bridge.js';
+/** Handle returned by `createInstrumentation()`. */
+export interface InstrumentationHandle {
+    /**
+     * Detach all event listeners from the bus.
+     * Call during graceful shutdown to prevent listener leaks.
+     */
+    detach: () => void;
+    /**
+     * Record a health cascade event as a point-in-time span.
+     *
+     * @param event - The CASCADE_APPLIED event from the CascadeEngine.
+     * @param traceId - Trace ID to correlate with the active operational context.
+     */
+    recordCascade: (event: CascadeAppliedEvent, traceId: string) => void;
+}
+/**
+ * Create and attach domain instrumentation to a RuntimeEventBus.
+ *
+ * Subscribes to all domain channels (plugin, mcp, transport, task, agent,
+ * permission, session, compaction) and creates OTel spans for each
+ * lifecycle state machine transition.
+ *
+ * @param tracer - The RuntimeTracer to use for span creation.
+ * @param bus - The RuntimeEventBus to subscribe to.
+ * @returns An InstrumentationHandle for cleanup and cascade recording.
+ */
+export declare function createInstrumentation(tracer: RuntimeTracer, bus: RuntimeEventBus): InstrumentationHandle;
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/runtime/telemetry/instrumentation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/telemetry/instrumentation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yDAAyD,CAAC;AAC7F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAG/F,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,oDAAoD;AACpD,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,MAAM,EAAE,MAAM,IAAI,CAAC;IAEnB;;;;;OAKG;IACH,aAAa,EAAE,CAAC,KAAK,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,eAAe,GACnB,qBAAqB,CASvB"}

package/dist/_internal/platform/runtime/telemetry/instrumentation/index.js

@@ -0,0 +1,21 @@
+import { DomainBridge } from './domain-bridge.js';
+export { DomainBridge } from './domain-bridge.js';
+/**
+ * Create and attach domain instrumentation to a RuntimeEventBus.
+ *
+ * Subscribes to all domain channels (plugin, mcp, transport, task, agent,
+ * permission, session, compaction) and creates OTel spans for each
+ * lifecycle state machine transition.
+ *
+ * @param tracer - The RuntimeTracer to use for span creation.
+ * @param bus - The RuntimeEventBus to subscribe to.
+ * @returns An InstrumentationHandle for cleanup and cascade recording.
+ */
+export function createInstrumentation(tracer, bus) {
+    const bridge = new DomainBridge(tracer);
+    const detach = bridge.attach(bus);
+    return {
+        detach,
+        recordCascade: (event, traceId) => bridge.recordCascade(event, traceId),
+    };
+}

package/dist/_internal/platform/runtime/tools/context.d.ts

@@ -0,0 +1,100 @@
+import type { HookDispatcher } from '../../hooks/dispatcher.js';
+import type { PermissionManager } from '../../permissions/manager.js';
+import type { FileStateCache } from '@pellux/goodvibes-sdk/platform/state/file-cache';
+import type { ProjectIndex } from '@pellux/goodvibes-sdk/platform/state/project-index';
+import type { RuntimeEventBus } from '../events/index.js';
+import type { OverflowHandler } from '@pellux/goodvibes-sdk/platform/tools/shared/overflow';
+/**
+ * Minimal read/subscribe interface over the Zustand RuntimeStore.
+ * Mirrors StoreApi<RuntimeState> without importing RuntimeState directly,
+ * keeping this module decoupled from the full store domain tree.
+ */
+export interface RuntimeStoreAccess {
+    /** Returns a snapshot of the current store state. */
+    getState(): Record<string, unknown>;
+    /** Subscribes to store changes; returns an unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+}
+/**
+ * TaskHooks — lifecycle callbacks for task/subtask tracking.
+ * Populated by higher tiers; all fields optional until wired.
+ */
+export interface TaskHooks {
+    /** Called when the tool begins execution. */
+    onStart?: (callId: string, toolName: string) => void;
+    /** Called when the tool completes (success or failure). */
+    onComplete?: (callId: string, durationMs: number) => void;
+    /** Called when the tool fails. */
+    onError?: (callId: string, error: string) => void;
+}
+/**
+ * ToolRuntimeContext — full context passed to each phase and to the tool itself.
+ *
+ * The typed runtime substrate is mandatory for tool execution; phase handlers
+ * should not need defensive guards around store or runtime-bus availability.
+ */
+export interface ToolRuntimeContext {
+    /** Read/subscribe access to the Zustand runtime store. */
+    runtime: RuntimeStoreAccess;
+    /** Correlation identifiers for the current execution context. */
+    ids: {
+        sessionId: string;
+        conversationId: string;
+        turnId: string;
+        toolCallId: string;
+        traceId: string;
+    };
+    /** Task lifecycle callbacks. */
+    tasks: TaskHooks;
+    /** Shared caches from the runtime context. */
+    resources: {
+        fileCache: FileStateCache;
+        projectIndex: ProjectIndex;
+    };
+    /** Shared overflow handler used by output-policy and exec tool result truncation. */
+    overflowHandler?: OverflowHandler;
+    /** Active provider and model identifiers. */
+    provider: {
+        providerId: string;
+        modelId: string;
+        contextWindow: number;
+    };
+    /** Agent context — present only when executing inside an agent scope. */
+    agent?: {
+        agentId: string;
+        parentAgentId?: string;
+        isolationMode: 'full' | 'partial' | 'none';
+    };
+    /**
+     * Execution budget constraints.
+     * All fields optional — absent means unlimited.
+     */
+    budget?: {
+        maxMs?: number;
+        maxTokens?: number;
+        maxCostUsd?: number;
+    };
+    /**
+     * Cancellation signal.
+     * Phases check `signal.aborted` at boundaries to support cooperative cancellation.
+     */
+    cancellation: {
+        signal: AbortSignal;
+        /** Human-readable reason set when the call is cancelled. */
+        reason?: string;
+    };
+    /** Execution mode — determines prompt and timeout behaviour. */
+    executionMode: 'interactive' | 'background' | 'remote';
+    /**
+     * Runtime event bus for structured phase and audit emission.
+     *
+     * ExecutorConfig still decides whether individual phase events are emitted,
+     * but the bus itself is a required runtime dependency.
+     */
+    runtimeBus: RuntimeEventBus;
+    /** Full PermissionManager instance (used by permission phase). */
+    permissionManager: PermissionManager;
+    /** Full HookDispatcher instance (used by pre/post hook phases). */
+    hookDispatcher: HookDispatcher;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/_internal/platform/runtime/tools/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/tools/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oDAAoD,CAAC;AACvF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sDAAsD,CAAC;AAE5F;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,qDAAqD;IACrD,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,oEAAoE;IACpE,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC7C;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,6CAA6C;IAC7C,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACrD,2DAA2D;IAC3D,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1D,kCAAkC;IAClC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACnD;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,0DAA0D;IAC1D,OAAO,EAAE,kBAAkB,CAAC;IAE5B,iEAAiE;IACjE,GAAG,EAAE;QACH,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,MAAM,CAAC;QACvB,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IAEF,gCAAgC;IAChC,KAAK,EAAE,SAAS,CAAC;IAEjB,8CAA8C;IAC9C,SAAS,EAAE;QACT,SAAS,EAAE,cAAc,CAAC;QAC1B,YAAY,EAAE,YAAY,CAAC;KAC5B,CAAC;IAEF,qFAAqF;IACrF,eAAe,CAAC,EAAE,eAAe,CAAC;IAElC,6CAA6C;IAC7C,QAAQ,EAAE;QACR,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;IAEF,yEAAyE;IACzE,KAAK,CAAC,EAAE;QACN,OAAO,EAAE,MAAM,CAAC;QAChB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;KAC5C,CAAC;IAEF;;;OAGG;IACH,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IAEF;;;OAGG;IACH,YAAY,EAAE;QACZ,MAAM,EAAE,WAAW,CAAC;QACpB,4DAA4D;QAC5D,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;IAEF,gEAAgE;IAChE,aAAa,EAAE,aAAa,GAAG,YAAY,GAAG,QAAQ,CAAC;IAEvD;;;;;OAKG;IACH,UAAU,EAAE,eAAe,CAAC;IAE5B,kEAAkE;IAClE,iBAAiB,EAAE,iBAAiB,CAAC;IAErC,mEAAmE;IACnE,cAAc,EAAE,cAAc,CAAC;CAChC"}

package/dist/_internal/platform/runtime/tools/context.js

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

package/dist/_internal/platform/runtime/tools/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * src/runtime/tools/index.ts — barrel and factory for the phased tool executor.
+ *
+ * Usage:
+ * ```ts
+ * import { createPhasedExecutor } from './runtime/tools/index.js';
+ *
+ * const executor = createPhasedExecutor({
+ *   enableHooks: true,
+ *   enablePermissions: true,
+ *   enableEvents: true,
+ * });
+ * const result = await executor.execute(call, tool, context);
+ * ```
+ */
+export type { ToolExecutionPhase, PhaseResult, ToolExecutionRecord, ExecutorConfig } from '@pellux/goodvibes-sdk/platform/runtime/tools/types';
+export type { ToolRuntimeContext, RuntimeStoreAccess, TaskHooks, } from './context.js';
+export { PhasedToolExecutor } from './phased-executor.js';
+export * from './phases/index.js';
+import { PhasedToolExecutor } from './phased-executor.js';
+import type { ExecutorConfig } from '@pellux/goodvibes-sdk/platform/runtime/tools/types';
+/**
+ * createPhasedExecutor — factory with sane defaults.
+ *
+ * Merges the provided partial config over the defaults so callers only
+ * need to specify what they want to change.
+ *
+ * @param config - Optional overrides for ExecutorConfig.
+ * @returns A fully configured PhasedToolExecutor instance.
+ */
+export declare function createPhasedExecutor(config?: Partial<ExecutorConfig>): PhasedToolExecutor;
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/runtime/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/tools/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,YAAY,EAAE,kBAAkB,EAAE,WAAW,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,oDAAoD,CAAC;AAC/I,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,SAAS,GACV,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,cAAc,mBAAmB,CAAC;AAElC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oDAAoD,CAAC;AASzF;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,kBAAkB,CAEzF"}

package/dist/_internal/platform/runtime/tools/index.js

@@ -0,0 +1,21 @@
+export { PhasedToolExecutor } from './phased-executor.js';
+export * from './phases/index.js';
+import { PhasedToolExecutor } from './phased-executor.js';
+/** Default executor configuration. */
+const DEFAULTS = {
+    enableHooks: true,
+    enablePermissions: true,
+    enableEvents: true,
+};
+/**
+ * createPhasedExecutor — factory with sane defaults.
+ *
+ * Merges the provided partial config over the defaults so callers only
+ * need to specify what they want to change.
+ *
+ * @param config - Optional overrides for ExecutorConfig.
+ * @returns A fully configured PhasedToolExecutor instance.
+ */
+export function createPhasedExecutor(config) {
+    return new PhasedToolExecutor({ ...DEFAULTS, ...config });
+}

package/dist/_internal/platform/runtime/tools/phased-executor.d.ts

@@ -0,0 +1,40 @@
+import type { Tool, ToolCall, ToolResult } from '@pellux/goodvibes-sdk/platform/types/tools';
+import type { ToolRuntimeContext } from './context.js';
+import type { ExecutorConfig, ToolExecutionRecord } from '@pellux/goodvibes-sdk/platform/runtime/tools/types';
+export declare class PhasedToolExecutor {
+    private readonly config;
+    private readonly records;
+    private readonly controllers;
+    /** Maps ToolCall instances to their idempotency key without mutating the input. */
+    private readonly _idKeyMap;
+    constructor(config: ExecutorConfig);
+    /**
+     * Execute a tool call through all pipeline phases.
+     * Returns a ToolResult regardless of outcome — callers never need to catch.
+     */
+    execute(call: ToolCall, tool: Tool, context: ToolRuntimeContext): Promise<ToolResult>;
+    /**
+     * Cancel an in-flight tool execution.
+     * Sets a cancelled flag on the record; the next phase boundary will pick it up.
+     */
+    cancel(callId: string, reason?: string): void;
+    /** Returns the full execution record for a given call id, if any. */
+    getRecord(callId: string): ToolExecutionRecord | undefined;
+    /** Returns all execution records for in-flight calls. */
+    getActiveRecords(): ToolExecutionRecord[];
+    /**
+     * Extract the idempotency key previously attached to a call during `execute`.
+     * Returns `undefined` if no idempotency store is configured.
+     */
+    private _getIdKey;
+    private _fail;
+    private _cancel;
+    /**
+     * Evicts the oldest completed records when the map exceeds MAX_RECORDS.
+     * Only completed records are eligible for eviction.
+     */
+    private _evictOldestCompleted;
+    private _emitBudgetEvent;
+    private _emitPhaseEvent;
+}
+//# sourceMappingURL=phased-executor.d.ts.map

package/dist/_internal/platform/runtime/tools/phased-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phased-executor.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/tools/phased-executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,4CAA4C,CAAC;AAE7F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAmC,mBAAmB,EAAE,MAAM,oDAAoD,CAAC;AA8C/I,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0C;IAClE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsC;IAClE,mFAAmF;IACnF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmC;gBAEjD,MAAM,EAAE,cAAc;IAIlC;;;OAGG;IACG,OAAO,CACX,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,UAAU,CAAC;IA2LtB;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAS7C,qEAAqE;IACrE,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAI1D,yDAAyD;IACzD,gBAAgB,IAAI,mBAAmB,EAAE;IAQzC;;;OAGG;IACH,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,KAAK;IAoCb,OAAO,CAAC,OAAO;IAsCf;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAU7B,OAAO,CAAC,gBAAgB;IAqCxB,OAAO,CAAC,eAAe;CAgCxB"}