glirastes 0.4.0 → 0.5.0

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

@@ -0,0 +1,112 @@
+import { type ExecutionBudget, 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 { 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. */
+    localLimits: ExecutionBudget;
+    /**
+     * 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. */
+    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,287 @@
+"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 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: 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 ?? '0.0.0',
+                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,23 @@
+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 { 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,71 @@
+"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.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 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-runtime-source.d.ts

@@ -0,0 +1,76 @@
+import { type AgentRevision, type ExecutionBudget, type ManifestRevision, type Principal } from '../contracts/index.js';
+import { type LocalRevisionSigner } from './local-signer.js';
+import type { LocalToolBinding } from './local-tool-bindings.js';
+import { type PolicyOverlayResult, type VerifiedPolicyOverlay } from './policy-overlay.js';
+import { type TurnSnapshot } from './turn-snapshot.js';
+export interface LocalRuntimeSourceOptions {
+    /** Parsed .glirastes artifacts; loading from disk is the caller's job. */
+    setupArtifact: unknown;
+    /** Optional locally generated prompt bundle (content-addressed). */
+    promptBundle?: unknown;
+    bindings: ReadonlyArray<LocalToolBinding>;
+    localLimits: ExecutionBudget;
+    /**
+     * Stable ids for the standalone world; defaults are derived
+     * deterministically from the setup artifact's app identity so restarts
+     * agree with themselves.
+     */
+    identity?: {
+        tenantId?: string;
+        targetAppId?: string;
+        environmentId?: string;
+    };
+    /**
+     * Managed mode only: returns the latest verified Platform overlay, e.g.
+     * `policyOverlayFromRevision(revisions.policyRevision)` for the deployment
+     * the sync manager accepted. It restricts the local policy and may switch a
+     * confirmation off only where the setup artifact allows it (D16). Called
+     * synchronously when a new turn starts; it must read local state, never
+     * the network.
+     */
+    policyOverlay?: () => VerifiedPolicyOverlay | undefined;
+    /**
+     * Managed mode only, required together with `policyOverlay`: the Platform
+     * agent and manifest revisions of the same accepted deployment, e.g. the
+     * sync manager's `MaterializedDeploymentRevisions`. The turn snapshot
+     * carries their ids so Platform revocations by `agentRevisionIds` keep
+     * matching (spec 4.9). Read with `policyOverlay` when a new turn starts.
+     *
+     * Both getters return undefined until a deployment was accepted; the turn
+     * then runs on the local base with derived ids, and only `toolIds`
+     * revocations can apply. Once a deployment was accepted, keep returning
+     * it, a revoked one included, so its revocations keep matching.
+     */
+    platformRevisions?: () => PlatformRevisionRefs | undefined;
+    /** Content-free report each time a new overlay revision is composed. */
+    onPolicyOverlayApplied?: (report: {
+        revisionId: string;
+        ignored: PolicyOverlayResult['ignored'];
+        relaxations: PolicyOverlayResult['relaxations'];
+    }) => void;
+    signer?: LocalRevisionSigner;
+}
+/** The Platform revisions a managed turn stands in for. */
+export interface PlatformRevisionRefs {
+    agentRevision: Pick<AgentRevision, 'revisionId' | 'revision'>;
+    manifestRevision: Pick<ManifestRevision, 'revisionId' | 'revision'>;
+}
+export interface LocalRuntimeSourceIdentity {
+    readonly tenantId: string;
+    readonly targetAppId: string;
+    readonly environmentId: string;
+}
+export interface LocalRuntimeSource {
+    readonly mode: 'standalone' | 'managed';
+    readonly keyId: string;
+    readonly identity: LocalRuntimeSourceIdentity;
+    /**
+     * Satisfies ManagedLocalRuntimeConfig.resolveTurnSnapshot. The same
+     * turnId returns the identical snapshot (approval continuations).
+     */
+    resolveTurnSnapshot(context: {
+        turnId: string;
+        principal: Principal;
+    }): TurnSnapshot;
+}
+export declare function createLocalRuntimeSource(options: LocalRuntimeSourceOptions): LocalRuntimeSource;