glirastes 0.4.0 → 0.5.1

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

@@ -0,0 +1,113 @@
+import { type Principal, type SecurityRevocation } from '../contracts/index.js';
+import type { ToolRegistry } from '../types.js';
+import { type ResolvedRuntimeConnection } from '../sync/connection-lookup.js';
+import type { RuntimePushConnector } from '../sync/control-plane-client.js';
+import { type MaterializedDeploymentRevisions } from '../sync/materialize-deployment.js';
+import { type ContractBindingsResult, type GeneratedToolBinding, type GeneratedToolModule } from './contract-bindings.js';
+import { type LocalRuntimeSource } from './local-runtime-source.js';
+import { type LocalToolBinding } from './local-tool-bindings.js';
+import { type RuntimeMetricsSinkOptions } from './metrics/sink.js';
+import type { RuntimeMetricsSink } from './metrics/turn-recorder.js';
+import { type LocalLimits } from './local-limits.js';
+import type { ToolSearchSemanticsMap } from './tool-discovery.js';
+import type { TurnSnapshot } from './turn-snapshot.js';
+/** The module `glirastes tools refresh` emits (`tools.generated.ts`). */
+export interface GlirastesGeneratedModule extends GeneratedToolModule {
+    readonly toolSearchSemantics?: ToolSearchSemanticsMap;
+}
+export interface CreateGlirastesOptions {
+    /** The generated module, e.g. `import * as generated from '@/generated/glirastes/tools.generated'`. */
+    generated: GlirastesGeneratedModule;
+    /** Local turn limits; the runtime never exceeds them, whatever a Platform revision allows. Unset fields use `DEFAULT_LOCAL_LIMITS`. */
+    localLimits?: LocalLimits;
+    /**
+     * Wraps the generated bindings before they are bound, e.g. to add write
+     * feedback to the endpoint tools. Called once per process.
+     */
+    wrapBindings?: (bindings: ReadonlyArray<GeneratedToolBinding>) => ReadonlyArray<GeneratedToolBinding>;
+    /** Defaults to `process.env`. Only `GLIRASTES_API_KEY` (and an optional `GLIRASTES_CONTROL_PLANE_URL`) are read. */
+    env?: Record<string, string | undefined>;
+    /**
+     * Content-free connection and sync errors (operation and status only).
+     * Defaults to one `console.error` line. The app keeps running on the local
+     * code whatever is reported here.
+     */
+    onError?: (error: unknown) => void;
+    /** The app version reported at runner registration. Defaults to `GLIRASTES_BUILD_ID`, else `glirastes@<sdk version>`. */
+    version?: string;
+    /** A technical runtime label reported at registration, e.g. `nextjs`. */
+    runtime?: string;
+    fetchImpl?: typeof fetch;
+    /** Push connector for revision updates; false polls only. */
+    push?: RuntimePushConnector | false;
+    /** Poll interval of the sync, and the retry interval of the lookup and registration (default 30 s). */
+    pollIntervalMs?: number;
+    /** How long `ready()` waits for the first sync (default 5 s). */
+    firstSyncTimeoutMs?: number;
+    /** Options for the metrics sink, or false to send no metrics. */
+    metrics?: Omit<RuntimeMetricsSinkOptions, 'controlPlaneUrl' | 'apiKey' | 'appId' | 'environmentId' | 'buildId' | 'fetch'> | false;
+}
+/** Builds the principal of a turn in the runtime tenant from the verified server session. */
+export type GlirastesPrincipalFactory = (runtimeTenantId: string, request: Request) => Principal | undefined | Promise<Principal | undefined>;
+/** What `createAiChatHandler` needs for one turn; spread it into the handler config. */
+export interface GlirastesChatTurn {
+    managedRuntime: {
+        resolvePrincipal: (request: Request) => Principal | undefined | Promise<Principal | undefined>;
+        resolveTurnSnapshot: (context: {
+            turnId: string;
+            principal: Principal;
+        }) => TurnSnapshot;
+        loadRevocations: (context: {
+            request: Request;
+            snapshot: TurnSnapshot;
+        }) => SecurityRevocation[];
+    };
+    loadTools: (context: {
+        turnSnapshot?: TurnSnapshot;
+    }) => ToolRegistry;
+    toolSemantics?: ToolSearchSemanticsMap;
+    metrics?: RuntimeMetricsSink;
+}
+export interface Glirastes {
+    /** `connected` when `GLIRASTES_API_KEY` is set, otherwise `standalone` (network-silent). */
+    readonly mode: 'standalone' | 'connected';
+    /** The local tool bindings of the code, after `wrapBindings`. */
+    readonly bindings: ReadonlyArray<LocalToolBinding>;
+    /** Tools of the setup artifact the code does not bind (any more). */
+    readonly disabled: ContractBindingsResult['disabled'];
+    readonly toolSearchSemantics: ToolSearchSemanticsMap | undefined;
+    /** The sink for turn metrics; undefined in Standalone and until the connection was looked up. */
+    readonly metrics: RuntimeMetricsSink | undefined;
+    /** The app, environment and runner the Platform answered for the key; undefined until then. */
+    connection(): ResolvedRuntimeConnection | undefined;
+    /**
+     * Starts the connection in the background (once) and resolves after the
+     * first sync or the first-sync timeout. Never rejects; resolves at once in
+     * Standalone.
+     */
+    ready(): Promise<void>;
+    /** The source of the next turn: the local code, or the accepted Platform deployment. */
+    currentSource(): LocalRuntimeSource;
+    /** The deployment the sync accepted; undefined before the first one. */
+    accepted(): MaterializedDeploymentRevisions | undefined;
+    /** The signed revocations the sync accepted, checked before every tool call. */
+    revocations(): SecurityRevocation[];
+    /** Waits for `ready()`, then returns what `createAiChatHandler` needs for one turn. */
+    chatTurn(principal: GlirastesPrincipalFactory): Promise<GlirastesChatTurn>;
+    /** Stops the sync, flushes the metrics and forgets this instance. */
+    stop(): Promise<void>;
+}
+/**
+ * The Glirastes runtime of one app: the tools derived from the code, and,
+ * connected, the Platform connection behind them. One instance per app and
+ * process: a second call with the same generated app returns the first
+ * instance (its options are ignored), so route bundles can each call it.
+ *
+ * Without `GLIRASTES_API_KEY` the app runs Standalone and never touches the
+ * network. With it, the first `ready()` (or `chatTurn()`) asks the Platform
+ * which app, environment and runner the key belongs to, registers, reports
+ * the code and syncs. Until that succeeds the turns run on the local code;
+ * failures go to `onError` and are retried. A key of a different app is an
+ * error, never a silent switch. A malformed key or URL throws here.
+ */
+export declare function createGlirastes(options: CreateGlirastesOptions): Glirastes;

package/dist/cjs/runtime/glirastes.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlirastes = createGlirastes;
+const index_js_1 = require("../contracts/index.js");
+const connection_lookup_js_1 = require("../sync/connection-lookup.js");
+const local_deployment_validator_js_1 = require("../sync/local-deployment-validator.js");
+const managed_sync_js_1 = require("../sync/managed-sync.js");
+const materialize_deployment_js_1 = require("../sync/materialize-deployment.js");
+const contract_bindings_js_1 = require("./contract-bindings.js");
+const local_runtime_source_js_1 = require("./local-runtime-source.js");
+const local_tool_bindings_js_1 = require("./local-tool-bindings.js");
+const sink_js_1 = require("./metrics/sink.js");
+const policy_overlay_js_1 = require("./policy-overlay.js");
+const runtime_mode_js_1 = require("./runtime-mode.js");
+const local_limits_js_1 = require("./local-limits.js");
+const sdk_version_js_1 = require("./sdk-version.js");
+const DEFAULT_FIRST_SYNC_TIMEOUT_MS = 5_000;
+const DEFAULT_RETRY_INTERVAL_MS = 30_000;
+/** Keeps the sync state in memory and the accepted deployment materialized for the turns. */
+class AcceptedStateStore {
+    state = null;
+    stable;
+    async load() {
+        return this.state ? structuredClone(this.state) : null;
+    }
+    async saveAtomic(state) {
+        this.state = structuredClone(state);
+        this.stable = state.stable ? (0, materialize_deployment_js_1.materializeDeploymentRevisions)(state.stable) : undefined;
+    }
+    accepted() {
+        return this.stable;
+    }
+    revocations() {
+        return this.state?.revocations ?? [];
+    }
+}
+function logError(error) {
+    // The SDK's request errors name the operation and the status only.
+    console.error('[Glirastes]', error instanceof Error ? error.message : 'connection failed');
+}
+function delay(milliseconds, signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = setTimeout(done, milliseconds);
+        timer.unref?.();
+        signal.addEventListener('abort', done, { once: true });
+        function done() {
+            clearTimeout(timer);
+            signal.removeEventListener('abort', done);
+            resolve();
+        }
+    });
+}
+// Next.js bundles instrumentation and each route separately, so the one
+// instance per app and process lives on globalThis, keyed by the app id.
+const INSTANCES = Symbol.for('glirastes.runtime.instances');
+function instances() {
+    const holder = globalThis;
+    holder[INSTANCES] ??= new Map();
+    return holder[INSTANCES];
+}
+/**
+ * The Glirastes runtime of one app: the tools derived from the code, and,
+ * connected, the Platform connection behind them. One instance per app and
+ * process: a second call with the same generated app returns the first
+ * instance (its options are ignored), so route bundles can each call it.
+ *
+ * Without `GLIRASTES_API_KEY` the app runs Standalone and never touches the
+ * network. With it, the first `ready()` (or `chatTurn()`) asks the Platform
+ * which app, environment and runner the key belongs to, registers, reports
+ * the code and syncs. Until that succeeds the turns run on the local code;
+ * failures go to `onError` and are retried. A key of a different app is an
+ * error, never a silent switch. A malformed key or URL throws here.
+ */
+function createGlirastes(options) {
+    const appId = index_js_1.AppSetupArtifactSchema.parse(options.generated.setupArtifact).appId;
+    const existing = instances().get(appId);
+    if (existing)
+        return existing;
+    const instance = createInstance(options, appId);
+    instances().set(appId, instance);
+    return instance;
+}
+function createInstance(options, appId) {
+    const env = options.env ?? process.env;
+    const config = (0, runtime_mode_js_1.resolveRuntimeConnectionConfig)(env);
+    const onError = (error) => {
+        try {
+            (options.onError ?? logError)(error);
+        }
+        catch {
+            // Reporting must never break the runtime.
+        }
+    };
+    const generated = options.wrapBindings
+        ? {
+            setupArtifact: options.generated.setupArtifact,
+            createToolBindings: () => options.wrapBindings(options.generated.createToolBindings()),
+        }
+        : options.generated;
+    const bound = (0, contract_bindings_js_1.createContractBindings)(generated);
+    const localSource = (identity, managed) => (0, local_runtime_source_js_1.createLocalRuntimeSource)({
+        setupArtifact: bound.setupArtifact,
+        bindings: bound.bindings,
+        localLimits: (0, local_limits_js_1.resolveLocalLimits)(options.localLimits),
+        ...(identity ? { identity } : {}),
+        ...(managed
+            ? {
+                policyOverlay: () => {
+                    const current = managed.accepted();
+                    return current && (0, policy_overlay_js_1.policyOverlayFromRevision)(current.policyRevision);
+                },
+                platformRevisions: managed.accepted,
+            }
+            : {}),
+    });
+    const base = localSource();
+    const store = new AcceptedStateStore();
+    const abort = new AbortController();
+    const retryMs = Math.max(1, options.pollIntervalMs ?? DEFAULT_RETRY_INTERVAL_MS);
+    let resolved;
+    let connectedBase;
+    let managed;
+    let metrics;
+    let stopSync;
+    let started = false;
+    // Settles after the first attempt, successful or not: a turn waits for the
+    // first sync at most once, not on every turn while the Platform is away.
+    let settleFirstAttempt;
+    const firstAttempt = new Promise((resolve) => {
+        settleFirstAttempt = resolve;
+    });
+    const connect = async () => {
+        if (!config)
+            return;
+        let connection;
+        while (!abort.signal.aborted && !connection) {
+            try {
+                connection = await (0, connection_lookup_js_1.lookupRuntimeConnection)({
+                    baseUrl: config.baseUrl,
+                    apiKey: config.apiKey,
+                    signal: abort.signal,
+                    ...(options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}),
+                });
+            }
+            catch (error) {
+                if (abort.signal.aborted)
+                    return;
+                onError(error);
+                settleFirstAttempt();
+                await delay(retryMs, abort.signal);
+            }
+        }
+        if (!connection || abort.signal.aborted)
+            return;
+        if (connection.appId !== appId) {
+            // A key of another app: report once and stay on the local code.
+            onError(new Error('The Glirastes runtime key belongs to a different app than this code'));
+            return;
+        }
+        let sync;
+        try {
+            sync = (0, managed_sync_js_1.createManagedRuntimeSync)({
+                baseUrl: config.baseUrl,
+                apiKey: config.apiKey,
+                appId: connection.appId,
+                environmentId: connection.environmentId,
+                runnerKey: connection.runnerKey,
+                version: options.version?.trim() || env.GLIRASTES_BUILD_ID?.trim() || `glirastes@${sdk_version_js_1.SDK_VERSION}`,
+                stateStore: store,
+                setupArtifact: options.generated.setupArtifact,
+                // A deployment that names a tool this code lacks, or has changed, keeps running on the local tool.
+                validateDeployment: (_deployment, revisions) => {
+                    (0, local_deployment_validator_js_1.validateLocalDeploymentBindings)({ revisions, bindings: bound.bindings });
+                },
+                onError,
+                ...(options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}),
+                ...(options.push !== undefined ? { push: options.push } : {}),
+                pollIntervalMs: retryMs,
+            });
+        }
+        catch (error) {
+            onError(error);
+            return;
+        }
+        resolved = connection;
+        connectedBase = localSource({
+            targetAppId: connection.appId,
+            environmentId: connection.environmentId,
+        });
+        if (options.metrics !== false) {
+            metrics = (0, sink_js_1.createRuntimeMetricsSinkFromEnv)(env, {
+                ...options.metrics,
+                connection,
+                ...(options.fetchImpl ? { fetch: options.fetchImpl } : {}),
+            });
+        }
+        stopSync = () => sync.client.stop();
+        while (!abort.signal.aborted) {
+            try {
+                await sync.client.register({
+                    capabilities: { aiSdk: true },
+                    technicalMetadata: { runtime: options.runtime ?? 'node' },
+                });
+                await sync.reportCapabilities().catch(onError);
+                await sync.client.syncOnce();
+                break;
+            }
+            catch (error) {
+                onError(error);
+                settleFirstAttempt();
+                await delay(retryMs, abort.signal);
+            }
+        }
+        if (!abort.signal.aborted)
+            void sync.client.start();
+    };
+    const instance = {
+        mode: config ? 'connected' : 'standalone',
+        bindings: bound.bindings,
+        disabled: bound.disabled,
+        toolSearchSemantics: options.generated.toolSearchSemantics,
+        get metrics() {
+            return metrics;
+        },
+        connection: () => resolved && { ...resolved },
+        ready() {
+            if (!config)
+                return Promise.resolve();
+            if (!started) {
+                started = true;
+                void connect().catch(onError).finally(settleFirstAttempt);
+            }
+            let timer;
+            const timeout = new Promise((resolve) => {
+                timer = setTimeout(resolve, options.firstSyncTimeoutMs ?? DEFAULT_FIRST_SYNC_TIMEOUT_MS);
+                timer.unref?.();
+            });
+            return Promise.race([firstAttempt, timeout]).finally(() => clearTimeout(timer));
+        },
+        currentSource() {
+            const accepted = store.accepted();
+            if (!resolved || !connectedBase)
+                return base;
+            if (!accepted)
+                return connectedBase;
+            // Signed Platform decisions restrict the local policy, never widen it.
+            const tenantId = accepted.policyRevision.tenantId;
+            if (managed?.tenantId !== tenantId) {
+                managed = {
+                    tenantId,
+                    source: localSource({ tenantId, targetAppId: resolved.appId, environmentId: resolved.environmentId }, { accepted: () => store.accepted() }),
+                };
+            }
+            return managed.source;
+        },
+        accepted: () => store.accepted(),
+        revocations: () => store.revocations(),
+        async chatTurn(principal) {
+            await instance.ready();
+            const source = instance.currentSource();
+            const tenantId = source.identity.tenantId;
+            const currentMetrics = metrics;
+            return {
+                managedRuntime: {
+                    resolvePrincipal: (request) => principal(tenantId, request),
+                    resolveTurnSnapshot: (context) => source.resolveTurnSnapshot(context),
+                    loadRevocations: () => store.revocations(),
+                },
+                loadTools: ({ turnSnapshot }) => (turnSnapshot
+                    ? (0, local_tool_bindings_js_1.materializeManifestToolRegistry)({ snapshot: turnSnapshot, bindings: bound.bindings })
+                    : {}),
+                ...(options.generated.toolSearchSemantics
+                    ? { toolSemantics: options.generated.toolSearchSemantics }
+                    : {}),
+                ...(currentMetrics ? { metrics: currentMetrics } : {}),
+            };
+        },
+        async stop() {
+            abort.abort();
+            stopSync?.();
+            if (instances().get(appId) === instance)
+                instances().delete(appId);
+            await metrics?.close();
+        },
+    };
+    return instance;
+}

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

@@ -0,0 +1,24 @@
+export { assertPromptPinForResume, createTurnSnapshot, isToolRevoked, type TurnSnapshot, } from './turn-snapshot.js';
+export { PromptBundleStore, type ActivePromptBundle, type PinnedPromptBundle, type PromptArtifactRegistry, type PromptBundleSections, type PromptBundleStoreOptions, type StagedPromptBundle, } from './prompt-bundle-store.js';
+export { authorizeToolCall, type ToolAuthorizationResult, } from './authorization.js';
+export { ExecutionBudgetTracker, type BudgetEvaluation, type BudgetReason, type ExecutionUsage, } from './budget.js';
+export { DEFAULT_LOCAL_LIMITS, resolveLocalLimits, type LocalLimits } from './local-limits.js';
+export { createExecutionFingerprint } from './fingerprint.js';
+export { DEFAULT_CONTROL_PLANE_URL, RUNTIME_API_KEY_PATTERN, resolveRuntimeConnectionConfig, resolveRuntimeMode, type RuntimeConnectionConfig, type RuntimeMode, } from './runtime-mode.js';
+export { createEphemeralLocalSigner, type LocalRevisionSigner, } from './local-signer.js';
+export { createLocalRuntimeSource, type LocalRuntimeSource, type LocalRuntimeSourceIdentity, type LocalRuntimeSourceOptions, type PlatformRevisionRefs, } from './local-runtime-source.js';
+export { createManagedTurnGuard, type ManagedTurnBudgetSignal, type ManagedTurnGuard, type ManagedTurnGuardOptions, } from './managed-turn.js';
+export { assertLocalToolBindingMatches, createLocalSchemaDigest, localToolBindingMismatches, materializeManifestToolRegistry, modelFacingToolName, type LocalEndpointToolBinding, type LocalToolBinding, type LocalUiToolBinding, type ToolRegistryDiagnostic, type ToolRegistryDiagnosticReason, } from './local-tool-bindings.js';
+export { applyPolicyOverlay, policyOverlayFromRevision, relaxableToolIds, type PolicyOverlayEntry, type PolicyOverlayIgnoredEntry, type PolicyOverlayOptions, type PolicyOverlayRelaxation, type PolicyOverlayRelaxationOutcome, type PolicyOverlayResult, type VerifiedPolicyOverlay, } from './policy-overlay.js';
+export { createRegistryToolDiscovery, createTurnToolDiscovery, type ToolDiscoveryResult, type ToolSearchSemantics, type ToolSearchSemanticsMap, type TurnToolDiscovery, type TurnToolDiscoveryOptions, } from './tool-discovery.js';
+export { createToolSearchIndex, searchTermVariants, searchTokens, type ToolSearchDocument, type ToolSearchIndex, } from './tool-search.js';
+export { createJsonSchemaLike, type JsonSchemaLike, type LocalJsonSchema, } from './json-schema.js';
+export { OfflineExecutionLeaseAuthorizer, type OfflineExecutionLeaseAuthorization, type OfflineExecutionLeaseScope, } from './offline-execution-lease.js';
+export type { RuntimeEngine, RuntimeEngineEvent, RuntimeRunRequest, } from './engine.js';
+export { CheckpointConflictError, POSTGRES_RUNTIME_STORE_SCHEMA_SQL, assertRuntimePersistenceReady, createPostgresRuntimeStore, type CompleteToolExecutionInput, type ConversationRecord, type ConversationVisibility, type DurableRuntimeStore, type LoadConversationInput, type PostgresQueryClient, type PostgresRuntimeStore, type ProjectConversationInput, type RuntimeCheckpoint, type RuntimeCheckpointStatus, type RuntimePersistenceRequirement, type RuntimeStoreScope, type SaveCheckpointInput, type SaveConversationInput, type ToolExecutionClaimInput, type ToolExecutionEvidence, type ToolExecutionStatus, } from './postgres-store.js';
+export { createContractBindings, createGeneratedRuntimeSource, type ContractBindingDisabledReason, type ContractBindingsResult, type GeneratedEndpointToolBinding, type GeneratedRuntimeSource, type GeneratedToolBinding, type GeneratedToolModule, type GeneratedUiToolBinding, } from './contract-bindings.js';
+export { RuntimePriceTableSchema, UNKNOWN_TURN_COST, combineTurnCost, providerReportedCostUsd, rawChunkCostUsd, resolveStepCost, type RuntimePriceTable, type StepCostInput, } from './metrics/cost.js';
+export { createTurnMetricsRecorder, type RuntimeMetricsIdentity, type RuntimeMetricsSink, type TurnMetricsOutcome, type TurnMetricsRecorder, type TurnMetricsRecorderOptions, type TurnMetricsStep, } from './metrics/turn-recorder.js';
+export { createRuntimeMetricsSink, createRuntimeMetricsSinkFromEnv, type BatchingRuntimeMetricsSink, type RuntimeMetricsDropReason, type RuntimeMetricsSinkOptions, } from './metrics/sink.js';
+export { createGlirastes, type CreateGlirastesOptions, type Glirastes, type GlirastesChatTurn, type GlirastesGeneratedModule, type GlirastesPrincipalFactory, } from './glirastes.js';
+export { lookupRuntimeConnection, type ResolvedRuntimeConnection, } from '../sync/connection-lookup.js';

package/dist/cjs/runtime/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupRuntimeConnection = exports.createGlirastes = exports.createRuntimeMetricsSinkFromEnv = exports.createRuntimeMetricsSink = exports.createTurnMetricsRecorder = exports.resolveStepCost = exports.rawChunkCostUsd = exports.providerReportedCostUsd = exports.combineTurnCost = exports.UNKNOWN_TURN_COST = exports.RuntimePriceTableSchema = exports.createGeneratedRuntimeSource = exports.createContractBindings = exports.createPostgresRuntimeStore = exports.assertRuntimePersistenceReady = exports.POSTGRES_RUNTIME_STORE_SCHEMA_SQL = exports.CheckpointConflictError = exports.OfflineExecutionLeaseAuthorizer = exports.createJsonSchemaLike = exports.searchTokens = exports.searchTermVariants = exports.createToolSearchIndex = exports.createTurnToolDiscovery = exports.createRegistryToolDiscovery = exports.relaxableToolIds = exports.policyOverlayFromRevision = exports.applyPolicyOverlay = exports.modelFacingToolName = exports.materializeManifestToolRegistry = exports.localToolBindingMismatches = exports.createLocalSchemaDigest = exports.assertLocalToolBindingMatches = exports.createManagedTurnGuard = exports.createLocalRuntimeSource = exports.createEphemeralLocalSigner = exports.resolveRuntimeMode = exports.resolveRuntimeConnectionConfig = exports.RUNTIME_API_KEY_PATTERN = exports.DEFAULT_CONTROL_PLANE_URL = exports.createExecutionFingerprint = exports.resolveLocalLimits = exports.DEFAULT_LOCAL_LIMITS = exports.ExecutionBudgetTracker = exports.authorizeToolCall = exports.PromptBundleStore = exports.isToolRevoked = exports.createTurnSnapshot = exports.assertPromptPinForResume = void 0;
+var turn_snapshot_js_1 = require("./turn-snapshot.js");
+Object.defineProperty(exports, "assertPromptPinForResume", { enumerable: true, get: function () { return turn_snapshot_js_1.assertPromptPinForResume; } });
+Object.defineProperty(exports, "createTurnSnapshot", { enumerable: true, get: function () { return turn_snapshot_js_1.createTurnSnapshot; } });
+Object.defineProperty(exports, "isToolRevoked", { enumerable: true, get: function () { return turn_snapshot_js_1.isToolRevoked; } });
+var prompt_bundle_store_js_1 = require("./prompt-bundle-store.js");
+Object.defineProperty(exports, "PromptBundleStore", { enumerable: true, get: function () { return prompt_bundle_store_js_1.PromptBundleStore; } });
+var authorization_js_1 = require("./authorization.js");
+Object.defineProperty(exports, "authorizeToolCall", { enumerable: true, get: function () { return authorization_js_1.authorizeToolCall; } });
+var budget_js_1 = require("./budget.js");
+Object.defineProperty(exports, "ExecutionBudgetTracker", { enumerable: true, get: function () { return budget_js_1.ExecutionBudgetTracker; } });
+var local_limits_js_1 = require("./local-limits.js");
+Object.defineProperty(exports, "DEFAULT_LOCAL_LIMITS", { enumerable: true, get: function () { return local_limits_js_1.DEFAULT_LOCAL_LIMITS; } });
+Object.defineProperty(exports, "resolveLocalLimits", { enumerable: true, get: function () { return local_limits_js_1.resolveLocalLimits; } });
+var fingerprint_js_1 = require("./fingerprint.js");
+Object.defineProperty(exports, "createExecutionFingerprint", { enumerable: true, get: function () { return fingerprint_js_1.createExecutionFingerprint; } });
+var runtime_mode_js_1 = require("./runtime-mode.js");
+Object.defineProperty(exports, "DEFAULT_CONTROL_PLANE_URL", { enumerable: true, get: function () { return runtime_mode_js_1.DEFAULT_CONTROL_PLANE_URL; } });
+Object.defineProperty(exports, "RUNTIME_API_KEY_PATTERN", { enumerable: true, get: function () { return runtime_mode_js_1.RUNTIME_API_KEY_PATTERN; } });
+Object.defineProperty(exports, "resolveRuntimeConnectionConfig", { enumerable: true, get: function () { return runtime_mode_js_1.resolveRuntimeConnectionConfig; } });
+Object.defineProperty(exports, "resolveRuntimeMode", { enumerable: true, get: function () { return runtime_mode_js_1.resolveRuntimeMode; } });
+var local_signer_js_1 = require("./local-signer.js");
+Object.defineProperty(exports, "createEphemeralLocalSigner", { enumerable: true, get: function () { return local_signer_js_1.createEphemeralLocalSigner; } });
+var local_runtime_source_js_1 = require("./local-runtime-source.js");
+Object.defineProperty(exports, "createLocalRuntimeSource", { enumerable: true, get: function () { return local_runtime_source_js_1.createLocalRuntimeSource; } });
+var managed_turn_js_1 = require("./managed-turn.js");
+Object.defineProperty(exports, "createManagedTurnGuard", { enumerable: true, get: function () { return managed_turn_js_1.createManagedTurnGuard; } });
+var local_tool_bindings_js_1 = require("./local-tool-bindings.js");
+Object.defineProperty(exports, "assertLocalToolBindingMatches", { enumerable: true, get: function () { return local_tool_bindings_js_1.assertLocalToolBindingMatches; } });
+Object.defineProperty(exports, "createLocalSchemaDigest", { enumerable: true, get: function () { return local_tool_bindings_js_1.createLocalSchemaDigest; } });
+Object.defineProperty(exports, "localToolBindingMismatches", { enumerable: true, get: function () { return local_tool_bindings_js_1.localToolBindingMismatches; } });
+Object.defineProperty(exports, "materializeManifestToolRegistry", { enumerable: true, get: function () { return local_tool_bindings_js_1.materializeManifestToolRegistry; } });
+Object.defineProperty(exports, "modelFacingToolName", { enumerable: true, get: function () { return local_tool_bindings_js_1.modelFacingToolName; } });
+var policy_overlay_js_1 = require("./policy-overlay.js");
+Object.defineProperty(exports, "applyPolicyOverlay", { enumerable: true, get: function () { return policy_overlay_js_1.applyPolicyOverlay; } });
+Object.defineProperty(exports, "policyOverlayFromRevision", { enumerable: true, get: function () { return policy_overlay_js_1.policyOverlayFromRevision; } });
+Object.defineProperty(exports, "relaxableToolIds", { enumerable: true, get: function () { return policy_overlay_js_1.relaxableToolIds; } });
+var tool_discovery_js_1 = require("./tool-discovery.js");
+Object.defineProperty(exports, "createRegistryToolDiscovery", { enumerable: true, get: function () { return tool_discovery_js_1.createRegistryToolDiscovery; } });
+Object.defineProperty(exports, "createTurnToolDiscovery", { enumerable: true, get: function () { return tool_discovery_js_1.createTurnToolDiscovery; } });
+var tool_search_js_1 = require("./tool-search.js");
+Object.defineProperty(exports, "createToolSearchIndex", { enumerable: true, get: function () { return tool_search_js_1.createToolSearchIndex; } });
+Object.defineProperty(exports, "searchTermVariants", { enumerable: true, get: function () { return tool_search_js_1.searchTermVariants; } });
+Object.defineProperty(exports, "searchTokens", { enumerable: true, get: function () { return tool_search_js_1.searchTokens; } });
+var json_schema_js_1 = require("./json-schema.js");
+Object.defineProperty(exports, "createJsonSchemaLike", { enumerable: true, get: function () { return json_schema_js_1.createJsonSchemaLike; } });
+var offline_execution_lease_js_1 = require("./offline-execution-lease.js");
+Object.defineProperty(exports, "OfflineExecutionLeaseAuthorizer", { enumerable: true, get: function () { return offline_execution_lease_js_1.OfflineExecutionLeaseAuthorizer; } });
+var postgres_store_js_1 = require("./postgres-store.js");
+Object.defineProperty(exports, "CheckpointConflictError", { enumerable: true, get: function () { return postgres_store_js_1.CheckpointConflictError; } });
+Object.defineProperty(exports, "POSTGRES_RUNTIME_STORE_SCHEMA_SQL", { enumerable: true, get: function () { return postgres_store_js_1.POSTGRES_RUNTIME_STORE_SCHEMA_SQL; } });
+Object.defineProperty(exports, "assertRuntimePersistenceReady", { enumerable: true, get: function () { return postgres_store_js_1.assertRuntimePersistenceReady; } });
+Object.defineProperty(exports, "createPostgresRuntimeStore", { enumerable: true, get: function () { return postgres_store_js_1.createPostgresRuntimeStore; } });
+var contract_bindings_js_1 = require("./contract-bindings.js");
+Object.defineProperty(exports, "createContractBindings", { enumerable: true, get: function () { return contract_bindings_js_1.createContractBindings; } });
+Object.defineProperty(exports, "createGeneratedRuntimeSource", { enumerable: true, get: function () { return contract_bindings_js_1.createGeneratedRuntimeSource; } });
+var cost_js_1 = require("./metrics/cost.js");
+Object.defineProperty(exports, "RuntimePriceTableSchema", { enumerable: true, get: function () { return cost_js_1.RuntimePriceTableSchema; } });
+Object.defineProperty(exports, "UNKNOWN_TURN_COST", { enumerable: true, get: function () { return cost_js_1.UNKNOWN_TURN_COST; } });
+Object.defineProperty(exports, "combineTurnCost", { enumerable: true, get: function () { return cost_js_1.combineTurnCost; } });
+Object.defineProperty(exports, "providerReportedCostUsd", { enumerable: true, get: function () { return cost_js_1.providerReportedCostUsd; } });
+Object.defineProperty(exports, "rawChunkCostUsd", { enumerable: true, get: function () { return cost_js_1.rawChunkCostUsd; } });
+Object.defineProperty(exports, "resolveStepCost", { enumerable: true, get: function () { return cost_js_1.resolveStepCost; } });
+var turn_recorder_js_1 = require("./metrics/turn-recorder.js");
+Object.defineProperty(exports, "createTurnMetricsRecorder", { enumerable: true, get: function () { return turn_recorder_js_1.createTurnMetricsRecorder; } });
+var sink_js_1 = require("./metrics/sink.js");
+Object.defineProperty(exports, "createRuntimeMetricsSink", { enumerable: true, get: function () { return sink_js_1.createRuntimeMetricsSink; } });
+Object.defineProperty(exports, "createRuntimeMetricsSinkFromEnv", { enumerable: true, get: function () { return sink_js_1.createRuntimeMetricsSinkFromEnv; } });
+var glirastes_js_1 = require("./glirastes.js");
+Object.defineProperty(exports, "createGlirastes", { enumerable: true, get: function () { return glirastes_js_1.createGlirastes; } });
+var connection_lookup_js_1 = require("../sync/connection-lookup.js");
+Object.defineProperty(exports, "lookupRuntimeConnection", { enumerable: true, get: function () { return connection_lookup_js_1.lookupRuntimeConnection; } });

package/dist/cjs/runtime/json-schema.d.ts

@@ -0,0 +1,13 @@
+import type { SchemaLike } from '../types.js';
+export type LocalJsonSchema = Readonly<Record<string, unknown>>;
+export interface JsonSchemaLike extends SchemaLike {
+    readonly jsonSchema: LocalJsonSchema;
+}
+export interface CreateJsonSchemaLikeOptions {
+    /**
+     * Project successful output payloads onto the declared contract. Input
+     * schemas must keep the default fail-closed behavior.
+     */
+    stripAdditionalProperties?: boolean;
+}
+export declare function createJsonSchemaLike(jsonSchema: LocalJsonSchema, options?: CreateJsonSchemaLikeOptions): JsonSchemaLike;

package/dist/cjs/runtime/json-schema.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJsonSchemaLike = createJsonSchemaLike;
+const ajv_1 = require("ajv");
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const addFormats = ajv_formats_1.default;
+function issuePath(error) {
+    if (!error.instancePath)
+        return [];
+    return error.instancePath
+        .split('/')
+        .slice(1)
+        .map((segment) => segment.replaceAll('~1', '/').replaceAll('~0', '~'));
+}
+function createJsonSchemaLike(jsonSchema, options = {}) {
+    const ajv = new ajv_1.Ajv({
+        allErrors: true,
+        allowUnionTypes: true,
+        strict: false,
+        useDefaults: true,
+        removeAdditional: options.stripAdditionalProperties ? 'failing' : false,
+    });
+    addFormats(ajv);
+    const validate = ajv.compile(jsonSchema);
+    return {
+        jsonSchema,
+        safeParse(value) {
+            const candidate = structuredClone(value);
+            if (validate(candidate)) {
+                return { success: true, data: candidate };
+            }
+            return {
+                success: false,
+                error: {
+                    issues: (validate.errors ?? []).map((error) => ({
+                        path: issuePath(error),
+                        message: error.message ?? error.keyword,
+                    })),
+                },
+            };
+        },
+    };
+}

package/dist/cjs/runtime/local-limits.d.ts

@@ -0,0 +1,6 @@
+import type { DelegationBudget, ExecutionBudget } from '../contracts/index.js';
+export type LocalLimits = Partial<Omit<ExecutionBudget, 'delegation'>> & {
+    delegation?: Partial<DelegationBudget>;
+};
+export declare const DEFAULT_LOCAL_LIMITS: ExecutionBudget;
+export declare function resolveLocalLimits(limits?: LocalLimits): ExecutionBudget;

package/dist/cjs/runtime/local-limits.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LOCAL_LIMITS = void 0;
+exports.resolveLocalLimits = resolveLocalLimits;
+exports.DEFAULT_LOCAL_LIMITS = {
+    maxModelSteps: 6,
+    maxToolCalls: 8,
+    totalTimeoutMs: 60_000,
+    toolTimeoutMs: 15_000,
+    maxInputTokens: 40_000,
+    maxOutputTokens: 4_000,
+    maxEstimatedCostUsd: 0.5,
+    maxRepeatedFingerprint: 3,
+    maxConsecutiveErrors: 3,
+    delegation: { maxDepth: 1, maxBreadth: 1, sharedBudget: true },
+};
+function defined(value) {
+    return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined));
+}
+function resolveLocalLimits(limits) {
+    return {
+        ...exports.DEFAULT_LOCAL_LIMITS,
+        ...defined(limits),
+        delegation: { ...exports.DEFAULT_LOCAL_LIMITS.delegation, ...defined(limits?.delegation) },
+    };
+}