glirastes 0.3.2 → 0.5.0

package/dist/cjs/runtime/ai-sdk/engine.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI_SDK_APPROVAL_GATE_PASSED = exports.AI_SDK_APPROVAL_GATE = void 0;
+exports.approvalGateOf = approvalGateOf;
+exports.createAiSdkTools = createAiSdkTools;
+const ai_1 = require("ai");
+exports.AI_SDK_APPROVAL_GATE = Symbol('glirastes.approvalGate');
+/**
+ * Set in the execution options that `createAiSdkTools` passes to the source
+ * tool once its gate authorized the call, so a source tool that checks the
+ * gate itself does not check the same execution twice (with the validated
+ * input, which differs for a schema that transforms).
+ */
+exports.AI_SDK_APPROVAL_GATE_PASSED = Symbol('glirastes.approvalGatePassed');
+function approvalGateOf(tool) {
+    if (typeof tool !== 'object' || tool === null)
+        return undefined;
+    return tool[exports.AI_SDK_APPROVAL_GATE];
+}
+function isJsonSchemaLike(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && 'jsonSchema' in value
+        && 'safeParse' in value
+        && typeof value.safeParse === 'function');
+}
+function toAiSdkInputSchema(parameters) {
+    if (!isJsonSchemaLike(parameters)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (0, ai_1.zodSchema)(parameters);
+    }
+    return (0, ai_1.jsonSchema)(parameters.jsonSchema, {
+        validate: (value) => {
+            const parsed = parameters.safeParse(value);
+            if (parsed.success)
+                return { success: true, value: parsed.data };
+            const detail = parsed.error.issues
+                .map((issue) => {
+                const path = issue.path?.join('.') ?? '';
+                return `${path}${path ? ': ' : ''}${issue.message ?? 'invalid value'}`;
+            })
+                .join('; ');
+            return {
+                success: false,
+                error: new Error(detail || 'Input does not match local JSON schema'),
+            };
+        },
+    });
+}
+function createAiSdkTools(options) {
+    const wrapped = {};
+    const now = options.now ?? (() => performance.now());
+    for (const [toolName, rawTool] of Object.entries(options.tools)) {
+        const source = rawTool;
+        const gate = approvalGateOf(rawTool);
+        const baseNeedsApproval = options.resolveApproval
+            ? (input) => options.resolveApproval({ toolName, input })
+            : source.needsApproval;
+        const decide = typeof baseNeedsApproval === 'function'
+            ? async (rawInput, approvalOptions) => {
+                let input;
+                try {
+                    input = await parseInput(rawInput);
+                }
+                catch {
+                    // The AI SDK validated the call just before; ask rather than guess.
+                    return true;
+                }
+                return Boolean(await baseNeedsApproval(input, approvalOptions));
+            }
+            : undefined;
+        const needsApproval = gate
+            ? async (rawInput, approvalOptions) => {
+                const needed = decide ? await decide(rawInput, approvalOptions) : baseNeedsApproval === true;
+                gate.recordDecision({ toolName, toolCallId: approvalOptions?.toolCallId, needed });
+                return needed;
+            }
+            : decide ?? baseNeedsApproval;
+        const inputSchema = toAiSdkInputSchema(source.parameters);
+        const validateInput = inputSchema.validate;
+        // One schema run per tool call. The AI SDK hands the object `validate`
+        // checked on to `needsApproval` and `execute` unchanged, so its schema
+        // output is kept here and reused, as long as the object still serializes
+        // the same: `needsApproval` decides on exactly the value that executes,
+        // even for a schema whose output differs from run to run.
+        const parsedInputs = new WeakMap();
+        const remember = (rawInput, value) => {
+            const snapshot = typeof rawInput === 'object' && rawInput !== null ? snapshotOf(rawInput) : undefined;
+            if (snapshot !== undefined)
+                parsedInputs.set(rawInput, { snapshot, value });
+        };
+        if (validateInput) {
+            inputSchema.validate = async (value) => {
+                const result = await validateInput(value);
+                if (!result.success)
+                    return result;
+                remember(value, result.value);
+                return { success: true, value };
+            };
+        }
+        const parseInput = async (rawInput) => {
+            if (!validateInput)
+                return rawInput;
+            if (typeof rawInput === 'object' && rawInput !== null) {
+                const known = parsedInputs.get(rawInput);
+                if (known && known.snapshot === snapshotOf(rawInput))
+                    return known.value;
+            }
+            const checked = await validateInput(rawInput);
+            if (!checked.success) {
+                throw new Error(`Invalid input for tool "${toolName}": ${checked.error.message}`);
+            }
+            remember(rawInput, checked.value);
+            return checked.value;
+        };
+        wrapped[toolName] = (0, ai_1.tool)({
+            description: source.description,
+            inputSchema,
+            needsApproval: needsApproval,
+            execute: async (rawInput, executionOptions) => {
+                if (gate) {
+                    gate.authorize({
+                        toolName,
+                        toolCallId: executionOptions?.toolCallId,
+                        input: rawInput,
+                    });
+                }
+                await options.beforeToolCall?.({ toolName, input: rawInput });
+                const startedAt = now();
+                let input = rawInput;
+                try {
+                    input = await parseInput(rawInput);
+                    const sourceOptions = gate
+                        ? { ...executionOptions, [exports.AI_SDK_APPROVAL_GATE_PASSED]: gate }
+                        : executionOptions;
+                    const execution = Promise.resolve(source.execute(input, sourceOptions));
+                    const result = options.toolTimeoutMs === undefined
+                        ? await execution
+                        : await withTimeout(execution, options.toolTimeoutMs, toolName);
+                    await options.afterToolCall?.({
+                        toolName,
+                        input,
+                        result,
+                        durationMs: Math.max(0, now() - startedAt),
+                    });
+                    return result;
+                }
+                catch (error) {
+                    await options.onToolError?.({
+                        toolName,
+                        input,
+                        error,
+                        durationMs: Math.max(0, now() - startedAt),
+                    });
+                    throw error;
+                }
+            },
+            // AI SDK's generic tool return type is wider than the stable surface
+            // Glirastes exposes here.
+        });
+    }
+    return wrapped;
+}
+function snapshotOf(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        // Not JSON (a cycle, a BigInt): not remembered, parsed at every use.
+        return undefined;
+    }
+}
+async function withTimeout(execution, timeoutMs, toolName) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        throw new RangeError('toolTimeoutMs must be a positive finite number');
+    }
+    let timeout;
+    try {
+        return await Promise.race([
+            execution,
+            new Promise((_resolve, reject) => {
+                timeout = setTimeout(() => {
+                    reject(new Error(`Tool "${toolName}" timed out after ${timeoutMs}ms`));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}

package/dist/cjs/runtime/ai-sdk/index.d.ts

@@ -0,0 +1 @@
+export { createAiSdkTools, type AiSdkSourceTool, type AiSdkToolCall, type AiSdkToolFailure, type AiSdkToolHooks, type AiSdkToolSuccess, type AiSdkWrappedTool, } from './engine.js';

package/dist/cjs/runtime/ai-sdk/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAiSdkTools = void 0;
+var engine_js_1 = require("./engine.js");
+Object.defineProperty(exports, "createAiSdkTools", { enumerable: true, get: function () { return engine_js_1.createAiSdkTools; } });

package/dist/cjs/runtime/authorization.d.ts

@@ -0,0 +1,16 @@
+import type { AgentRevision, ManifestRevision, Principal, RuntimePolicyRevision, ToolRiskClass } from '../contracts/index.js';
+export type ToolAuthorizationResult = {
+    allowed: true;
+    requiresApproval: boolean;
+    riskClass: ToolRiskClass;
+} | {
+    allowed: false;
+    reason: 'missing_principal' | 'tenant_mismatch' | 'agent_tool_denied' | 'manifest_tool_unavailable' | 'policy_tool_denied' | 'principal_role_denied';
+};
+export declare function authorizeToolCall(options: {
+    principal: Principal | undefined;
+    agentRevision: AgentRevision;
+    manifestRevision: ManifestRevision;
+    policyRevision: RuntimePolicyRevision;
+    toolId: string;
+}): ToolAuthorizationResult;

package/dist/cjs/runtime/authorization.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authorizeToolCall = authorizeToolCall;
+const tool_policy_js_1 = require("../contracts/tool-policy.js");
+function authorizeToolCall(options) {
+    const { principal, agentRevision, manifestRevision, policyRevision, toolId, } = options;
+    if (!principal)
+        return { allowed: false, reason: 'missing_principal' };
+    if (principal.tenantId !== agentRevision.tenantId
+        || principal.tenantId !== manifestRevision.tenantId
+        || principal.tenantId !== policyRevision.tenantId) {
+        return { allowed: false, reason: 'tenant_mismatch' };
+    }
+    if (!agentRevision.toolAllowlist.includes(toolId)) {
+        return { allowed: false, reason: 'agent_tool_denied' };
+    }
+    const manifestTool = manifestRevision.tools.find((tool) => tool.toolId === toolId);
+    if (!manifestTool || !manifestTool.enabled || manifestTool.tombstone) {
+        return { allowed: false, reason: 'manifest_tool_unavailable' };
+    }
+    const policy = policyRevision.toolPolicies.find((tool) => tool.toolId === toolId);
+    if (!policy || !policy.enabled) {
+        return { allowed: false, reason: 'policy_tool_denied' };
+    }
+    if (policy.allowedRoles.length > 0
+        && !policy.allowedRoles.some((role) => principal.roles.includes(role))) {
+        return { allowed: false, reason: 'principal_role_denied' };
+    }
+    return {
+        allowed: true,
+        // Tier 3 always confirms, whatever the pinned policy says.
+        requiresApproval: (0, tool_policy_js_1.confirmationFloor)(policy.riskClass, policy.requiresApproval),
+        riskClass: policy.riskClass,
+    };
+}

package/dist/cjs/runtime/budget.d.ts

@@ -0,0 +1,39 @@
+import type { ExecutionBudget } from '../contracts/index.js';
+export interface ExecutionUsage {
+    modelSteps: number;
+    toolCalls: number;
+    inputTokens: number;
+    outputTokens: number;
+    estimatedCostUsd: number;
+    consecutiveErrors: number;
+    maxFingerprintRepeats: number;
+    elapsedMs: number;
+}
+export type BudgetReason = 'maxModelSteps' | 'maxToolCalls' | 'totalTimeoutMs' | 'maxInputTokens' | 'maxOutputTokens' | 'maxEstimatedCostUsd' | 'maxRepeatedFingerprint' | 'maxConsecutiveErrors';
+export interface BudgetEvaluation {
+    state: 'within-budget' | 'soft-limit' | 'hard-limit';
+    reasons: BudgetReason[];
+}
+export declare class ExecutionBudgetTracker {
+    readonly budget: ExecutionBudget;
+    private readonly startedAtMs;
+    private readonly now;
+    private readonly fingerprints;
+    private finalSummaryClaimed;
+    private counters;
+    constructor(budget: ExecutionBudget, clock?: {
+        now?: () => number;
+        startedAtMs?: number;
+    });
+    get usage(): ExecutionUsage;
+    recordModelStep(): void;
+    recordToolCall(): void;
+    recordTokens(inputTokens: number, outputTokens: number): void;
+    recordEstimatedCost(costUsd: number): void;
+    recordError(): void;
+    recordSuccess(): void;
+    recordFingerprint(fingerprint: string): void;
+    evaluate(): BudgetEvaluation;
+    claimFinalSummary(): boolean;
+    private requireFiniteNonnegative;
+}

package/dist/cjs/runtime/budget.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionBudgetTracker = void 0;
+class ExecutionBudgetTracker {
+    budget;
+    startedAtMs;
+    now;
+    fingerprints = new Map();
+    finalSummaryClaimed = false;
+    counters = {
+        modelSteps: 0,
+        toolCalls: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        estimatedCostUsd: 0,
+        consecutiveErrors: 0,
+        maxFingerprintRepeats: 0,
+    };
+    constructor(budget, clock = {}) {
+        this.budget = budget;
+        this.now = clock.now ?? Date.now;
+        this.startedAtMs = clock.startedAtMs ?? this.now();
+    }
+    get usage() {
+        return {
+            ...this.counters,
+            elapsedMs: Math.max(0, this.now() - this.startedAtMs),
+        };
+    }
+    recordModelStep() {
+        this.counters.modelSteps += 1;
+    }
+    recordToolCall() {
+        this.counters.toolCalls += 1;
+    }
+    recordTokens(inputTokens, outputTokens) {
+        this.counters.inputTokens += this.requireFiniteNonnegative(inputTokens, 'inputTokens');
+        this.counters.outputTokens += this.requireFiniteNonnegative(outputTokens, 'outputTokens');
+    }
+    recordEstimatedCost(costUsd) {
+        this.counters.estimatedCostUsd += this.requireFiniteNonnegative(costUsd, 'estimatedCostUsd');
+    }
+    recordError() {
+        this.counters.consecutiveErrors += 1;
+    }
+    recordSuccess() {
+        this.counters.consecutiveErrors = 0;
+    }
+    recordFingerprint(fingerprint) {
+        const count = (this.fingerprints.get(fingerprint) ?? 0) + 1;
+        this.fingerprints.set(fingerprint, count);
+        this.counters.maxFingerprintRepeats = Math.max(this.counters.maxFingerprintRepeats, count);
+    }
+    evaluate() {
+        const usage = this.usage;
+        const dimensions = [
+            ['maxModelSteps', usage.modelSteps, this.budget.maxModelSteps],
+            ['maxToolCalls', usage.toolCalls, this.budget.maxToolCalls],
+            ['totalTimeoutMs', usage.elapsedMs, this.budget.totalTimeoutMs],
+            ['maxInputTokens', usage.inputTokens, this.budget.maxInputTokens],
+            ['maxOutputTokens', usage.outputTokens, this.budget.maxOutputTokens],
+            ['maxEstimatedCostUsd', usage.estimatedCostUsd, this.budget.maxEstimatedCostUsd],
+            [
+                'maxRepeatedFingerprint',
+                usage.maxFingerprintRepeats,
+                this.budget.maxRepeatedFingerprint,
+            ],
+            [
+                'maxConsecutiveErrors',
+                usage.consecutiveErrors,
+                this.budget.maxConsecutiveErrors,
+            ],
+        ];
+        const hard = dimensions
+            .filter(([, value, limit]) => limit === 0 ? value > 0 : value >= limit)
+            .map(([reason]) => reason);
+        if (hard.length > 0)
+            return { state: 'hard-limit', reasons: hard };
+        const soft = dimensions
+            .filter(([, value, limit]) => limit > 0 && value / limit >= 0.8)
+            .map(([reason]) => reason);
+        if (soft.length > 0)
+            return { state: 'soft-limit', reasons: soft };
+        return { state: 'within-budget', reasons: [] };
+    }
+    claimFinalSummary() {
+        if (this.evaluate().state !== 'hard-limit' || this.finalSummaryClaimed) {
+            return false;
+        }
+        this.finalSummaryClaimed = true;
+        return true;
+    }
+    requireFiniteNonnegative(value, field) {
+        if (!Number.isFinite(value) || value < 0) {
+            throw new RangeError(`${field} must be a finite nonnegative number`);
+        }
+        return value;
+    }
+}
+exports.ExecutionBudgetTracker = ExecutionBudgetTracker;

package/dist/cjs/runtime/contract-bindings.d.ts

@@ -0,0 +1,52 @@
+import { type AppSetupArtifact } from '../contracts/index.js';
+import type { EndpointMethod, SchemaLike, Tool } from '../types.js';
+import { type LocalRuntimeSource, type LocalRuntimeSourceOptions } from './local-runtime-source.js';
+import { type LocalToolBinding } from './local-tool-bindings.js';
+interface GeneratedToolBindingBase {
+    readonly toolId: string;
+    readonly definitionId: string;
+    readonly sourceFingerprint: string;
+    readonly inputSchemaDigest: string;
+    readonly outputSchemaDigest: string;
+    readonly inputSchema: SchemaLike;
+    readonly outputSchema: SchemaLike;
+    readonly tool: Tool;
+}
+export interface GeneratedEndpointToolBinding extends GeneratedToolBindingBase {
+    readonly executionKind: 'endpoint';
+    readonly method: EndpointMethod;
+    readonly path: string;
+}
+/** Navigation, filter and client action tools; they run in the browser. */
+export interface GeneratedUiToolBinding extends GeneratedToolBindingBase {
+    readonly executionKind: 'ui';
+    readonly actionBindingRef: string;
+}
+/** One entry of `createToolBindings()` in the generated module. */
+export type GeneratedToolBinding = GeneratedEndpointToolBinding | GeneratedUiToolBinding;
+/** The shape of `src/generated/glirastes/tools.generated.ts`. */
+export interface GeneratedToolModule {
+    readonly setupArtifact: unknown;
+    createToolBindings(): ReadonlyArray<GeneratedToolBinding>;
+}
+export type ContractBindingDisabledReason = 'binding-missing' | 'binding-duplicated' | 'binding-mismatch' | 'input-schema-digest-mismatch' | 'output-schema-digest-mismatch';
+export interface ContractBindingsResult {
+    setupArtifact: AppSetupArtifact;
+    bindings: LocalToolBinding[];
+    disabled: Array<{
+        toolId: string;
+        reason: ContractBindingDisabledReason;
+    }>;
+}
+/**
+ * Recomputes every schema digest from the live schema objects at boot and
+ * disables only tools whose binding is missing or differs from the artifact.
+ */
+export declare function createContractBindings(generated: GeneratedToolModule): ContractBindingsResult;
+export interface GeneratedRuntimeSource {
+    source: LocalRuntimeSource;
+    bindings: LocalToolBinding[];
+    disabled: ContractBindingsResult['disabled'];
+}
+export declare function createGeneratedRuntimeSource(generated: GeneratedToolModule, options: Omit<LocalRuntimeSourceOptions, 'setupArtifact' | 'bindings'>): GeneratedRuntimeSource;
+export {};

package/dist/cjs/runtime/contract-bindings.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContractBindings = createContractBindings;
+exports.createGeneratedRuntimeSource = createGeneratedRuntimeSource;
+const index_js_1 = require("../contracts/index.js");
+const local_runtime_source_js_1 = require("./local-runtime-source.js");
+const local_tool_bindings_js_1 = require("./local-tool-bindings.js");
+function byToolId(left, right) {
+    return left.toolId < right.toolId ? -1 : left.toolId > right.toolId ? 1 : 0;
+}
+/** Same kind, same route or action binding, same fingerprint and digests. */
+function sameBinding(candidate, binding) {
+    if (candidate.sourceFingerprint !== binding.sourceFingerprint
+        || candidate.inputSchemaDigest !== binding.inputSchemaDigest
+        || candidate.outputSchemaDigest !== binding.outputSchemaDigest) {
+        return false;
+    }
+    if (binding.executionKind === 'endpoint') {
+        return candidate.executionKind === 'endpoint'
+            && candidate.method === binding.method
+            && candidate.path === binding.path;
+    }
+    return candidate.executionKind === 'ui'
+        && candidate.actionBindingRef === binding.actionBindingRef;
+}
+function toLocalBinding(binding) {
+    const common = {
+        toolId: binding.toolId,
+        sourceFingerprint: binding.sourceFingerprint,
+        inputSchemaDigest: binding.inputSchemaDigest,
+        outputSchemaDigest: binding.outputSchemaDigest,
+        tool: binding.tool,
+    };
+    return binding.executionKind === 'endpoint'
+        ? { ...common, executionKind: 'endpoint', method: binding.method, path: binding.path }
+        : { ...common, executionKind: 'ui', actionBindingRef: binding.actionBindingRef };
+}
+/**
+ * Recomputes every schema digest from the live schema objects at boot and
+ * disables only tools whose binding is missing or differs from the artifact.
+ */
+function createContractBindings(generated) {
+    const artifact = index_js_1.AppSetupArtifactSchema.parse(generated.setupArtifact);
+    const candidates = new Map(artifact.tools.map((tool) => [tool.toolId, tool]));
+    const grouped = new Map();
+    for (const binding of generated.createToolBindings()) {
+        grouped.set(binding.toolId, [...grouped.get(binding.toolId) ?? [], binding]);
+    }
+    const disabled = new Map();
+    const bindings = [];
+    for (const [toolId, entries] of grouped) {
+        const candidate = candidates.get(toolId);
+        if (!candidate?.enabled)
+            continue;
+        if (entries.length !== 1) {
+            disabled.set(toolId, 'binding-duplicated');
+            continue;
+        }
+        const binding = entries[0];
+        if (!sameBinding(candidate, binding)) {
+            disabled.set(toolId, 'binding-mismatch');
+            continue;
+        }
+        if ((0, local_tool_bindings_js_1.createLocalSchemaDigest)(binding.inputSchema) !== candidate.inputSchemaDigest) {
+            disabled.set(toolId, 'input-schema-digest-mismatch');
+            continue;
+        }
+        if ((0, local_tool_bindings_js_1.createLocalSchemaDigest)(binding.outputSchema) !== candidate.outputSchemaDigest) {
+            disabled.set(toolId, 'output-schema-digest-mismatch');
+            continue;
+        }
+        bindings.push(toLocalBinding(binding));
+    }
+    for (const tool of artifact.tools) {
+        if (tool.enabled && !grouped.has(tool.toolId))
+            disabled.set(tool.toolId, 'binding-missing');
+    }
+    const setupArtifact = index_js_1.AppSetupArtifactSchema.parse({
+        ...artifact,
+        tools: artifact.tools.map((tool) => (disabled.has(tool.toolId) ? { ...tool, enabled: false } : tool)),
+    });
+    return {
+        setupArtifact,
+        bindings: bindings.sort(byToolId),
+        disabled: [...disabled].map(([toolId, reason]) => ({ toolId, reason })).sort(byToolId),
+    };
+}
+function createGeneratedRuntimeSource(generated, options) {
+    const result = createContractBindings(generated);
+    return {
+        source: (0, local_runtime_source_js_1.createLocalRuntimeSource)({ ...options, setupArtifact: result.setupArtifact, bindings: result.bindings }),
+        bindings: result.bindings,
+        disabled: result.disabled,
+    };
+}

package/dist/cjs/runtime/engine.d.ts

@@ -0,0 +1,52 @@
+export interface RuntimeRunRequest {
+    runId: string;
+    turnId: string;
+    messages: unknown[];
+    tools: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+interface RuntimeEventBase {
+    runId: string;
+    turnId: string;
+    occurredAt: string;
+}
+export type RuntimeEngineEvent = (RuntimeEventBase & {
+    type: 'run.started';
+}) | (RuntimeEventBase & {
+    type: 'model.step';
+    step: number;
+    inputTokens?: number;
+    outputTokens?: number;
+}) | (RuntimeEventBase & {
+    type: 'tool.started';
+    toolName: string;
+    toolCallId?: string;
+    input?: unknown;
+}) | (RuntimeEventBase & {
+    type: 'tool.completed';
+    toolName: string;
+    toolCallId?: string;
+    result?: unknown;
+    durationMs: number;
+}) | (RuntimeEventBase & {
+    type: 'tool.failed';
+    toolName: string;
+    toolCallId?: string;
+    errorClass: string;
+    durationMs: number;
+}) | (RuntimeEventBase & {
+    type: 'approval.pending';
+    toolName: string;
+    toolCallId?: string;
+}) | (RuntimeEventBase & {
+    type: 'checkpoint.saved';
+    checkpointId: string;
+}) | (RuntimeEventBase & {
+    type: 'run.completed';
+    status: 'completed' | 'cancelled' | 'failed' | 'budget_exhausted';
+    reason?: string;
+});
+export interface RuntimeEngine {
+    run(request: RuntimeRunRequest): AsyncIterable<RuntimeEngineEvent>;
+}
+export {};

package/dist/cjs/runtime/engine.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/runtime/fingerprint.d.ts

@@ -0,0 +1,6 @@
+export declare function createExecutionFingerprint(input: {
+    toolId: string;
+    arguments: unknown;
+    result: unknown;
+    progress?: unknown;
+}): string;

package/dist/cjs/runtime/fingerprint.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExecutionFingerprint = createExecutionFingerprint;
+const node_crypto_1 = require("node:crypto");
+function normalize(value, seen) {
+    if (value === null || typeof value !== 'object') {
+        if (typeof value === 'bigint')
+            return value.toString();
+        if (value === undefined)
+            return null;
+        return value;
+    }
+    if (seen.has(value))
+        throw new TypeError('Cannot fingerprint cyclic data');
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const normalized = value.map((item) => normalize(item, seen));
+        seen.delete(value);
+        return normalized;
+    }
+    const normalized = {};
+    for (const key of Object.keys(value).sort()) {
+        normalized[key] = normalize(value[key], seen);
+    }
+    seen.delete(value);
+    return normalized;
+}
+function createExecutionFingerprint(input) {
+    const serialized = JSON.stringify(normalize(input, new WeakSet()));
+    return `sha256:${(0, node_crypto_1.createHash)('sha256').update(serialized).digest('base64url')}`;
+}