glirastes 0.4.0 → 0.5.0

package/dist/cjs/contracts/events.d.ts

@@ -0,0 +1,273 @@
+import { z } from 'zod';
+export declare const TechnicalRuntimeEventSchema: z.ZodObject<{
+    eventId: z.ZodUUID;
+    occurredAt: z.ZodISODateTime;
+    eventType: z.ZodString;
+    tenantId: z.ZodUUID;
+    targetAppId: z.ZodUUID;
+    environmentId: z.ZodUUID;
+    agentRevisionId: z.ZodOptional<z.ZodUUID>;
+    policyRevisionId: z.ZodOptional<z.ZodUUID>;
+    manifestRevisionId: z.ZodOptional<z.ZodUUID>;
+    runId: z.ZodString;
+    status: z.ZodString;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    errorClass: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        modelSteps: z.ZodNumber;
+        toolCalls: z.ZodNumber;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        estimatedCostUsd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type TechnicalRuntimeEvent = z.infer<typeof TechnicalRuntimeEventSchema>;
+export declare const RUNTIME_METRIC_EVENT_SCHEMA_VERSION = 2;
+/** Most events one ingest request carries (keeps a batch far below 256 KB). */
+export declare const RUNTIME_METRIC_MAX_BATCH = 50;
+/** Most distinct tools one turn event lists; further tools only count. */
+export declare const RUNTIME_METRIC_MAX_TOOLS = 32;
+/** Largest count or token number a metric carries (Postgres `integer`). */
+export declare const RUNTIME_METRIC_MAX_COUNT = 2147483647;
+/**
+ * A technical label (model slug, build id, instance id): no whitespace, no
+ * quotes, at most 200 characters. Free text cannot pass.
+ */
+export declare const RUNTIME_METRIC_LABEL_PATTERN: RegExp;
+export declare const RUNTIME_PRICING_VERSION_PATTERN: RegExp;
+export declare const RuntimeTurnStatusSchema: z.ZodEnum<{
+    error: "error";
+    completed: "completed";
+    "safety-stop": "safety-stop";
+    aborted: "aborted";
+}>;
+export declare const RuntimeTurnErrorCodeSchema: z.ZodEnum<{
+    model_error: "model_error";
+    pipeline_error: "pipeline_error";
+    budget_exhausted: "budget_exhausted";
+    step_limit: "step_limit";
+}>;
+export declare const RuntimeCostSourceSchema: z.ZodEnum<{
+    "provider-reported": "provider-reported";
+    "price-table": "price-table";
+}>;
+/**
+ * Cost of a turn with its provenance. Unknown stays `null`, never 0: a
+ * provider-reported amount (OpenRouter `usage.cost`) or a price-table
+ * estimate that names its pricing version.
+ */
+export declare const RuntimeTurnCostSchema: z.ZodObject<{
+    usd: z.ZodNullable<z.ZodNumber>;
+    source: z.ZodNullable<z.ZodEnum<{
+        "provider-reported": "provider-reported";
+        "price-table": "price-table";
+    }>>;
+    pricingVersion: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const RuntimeTurnToolUsageSchema: z.ZodObject<{
+    toolId: z.ZodUUID;
+    calls: z.ZodNumber;
+    errors: z.ZodNumber;
+}, z.core.$strict>;
+export declare const TechnicalRuntimeEventV2Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    eventId: z.ZodUUID;
+    eventType: z.ZodLiteral<"turn.finished">;
+    occurredAt: z.ZodISODateTime;
+    appId: z.ZodUUID;
+    environmentId: z.ZodUUID;
+    buildId: z.ZodNullable<z.ZodString>;
+    instanceId: z.ZodString;
+    revisionId: z.ZodNullable<z.ZodUUID>;
+    model: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        error: "error";
+        completed: "completed";
+        "safety-stop": "safety-stop";
+        aborted: "aborted";
+    }>;
+    errorCode: z.ZodNullable<z.ZodEnum<{
+        model_error: "model_error";
+        pipeline_error: "pipeline_error";
+        budget_exhausted: "budget_exhausted";
+        step_limit: "step_limit";
+    }>>;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    cost: z.ZodObject<{
+        usd: z.ZodNullable<z.ZodNumber>;
+        source: z.ZodNullable<z.ZodEnum<{
+            "provider-reported": "provider-reported";
+            "price-table": "price-table";
+        }>>;
+        pricingVersion: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    latency: z.ZodObject<{
+        firstTokenMs: z.ZodNullable<z.ZodNumber>;
+        totalMs: z.ZodNumber;
+    }, z.core.$strict>;
+    toolCallCount: z.ZodNumber;
+    toolErrorCount: z.ZodNumber;
+    tools: z.ZodArray<z.ZodObject<{
+        toolId: z.ZodUUID;
+        calls: z.ZodNumber;
+        errors: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TechnicalRuntimeEventV2 = z.infer<typeof TechnicalRuntimeEventV2Schema>;
+export type RuntimeTurnStatus = z.infer<typeof RuntimeTurnStatusSchema>;
+export type RuntimeTurnErrorCode = z.infer<typeof RuntimeTurnErrorCodeSchema>;
+export type RuntimeCostSource = z.infer<typeof RuntimeCostSourceSchema>;
+export type RuntimeTurnCost = z.infer<typeof RuntimeTurnCostSchema>;
+export type RuntimeTurnToolUsage = z.infer<typeof RuntimeTurnToolUsageSchema>;
+/** Statuses of an endpoint that refused a call its tool schema accepted. */
+export declare const TOOL_CONTRACT_REJECTED_STATUSES: readonly [400, 422];
+/**
+ * An endpoint refused a call that passed the tool's input schema (spec 4.7):
+ * the contract the model saw is wrong, so the tool belongs on the next work
+ * list or managed job. Content-free: tool, schema version and status, never
+ * arguments, response or message.
+ */
+export declare const ToolContractRejectedEventSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    eventId: z.ZodUUID;
+    eventType: z.ZodLiteral<"tool_contract_rejected">;
+    occurredAt: z.ZodISODateTime;
+    appId: z.ZodUUID;
+    environmentId: z.ZodUUID;
+    buildId: z.ZodNullable<z.ZodString>;
+    instanceId: z.ZodString;
+    revisionId: z.ZodNullable<z.ZodUUID>;
+    toolId: z.ZodUUID;
+    inputSchemaDigest: z.ZodString;
+    httpStatus: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<422>]>;
+}, z.core.$strict>;
+export type ToolContractRejectedEvent = z.infer<typeof ToolContractRejectedEventSchema>;
+/** Every content-free metric event of the runtime: finished turns and contract rejections. */
+export declare const RuntimeMetricEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    eventId: z.ZodUUID;
+    eventType: z.ZodLiteral<"turn.finished">;
+    occurredAt: z.ZodISODateTime;
+    appId: z.ZodUUID;
+    environmentId: z.ZodUUID;
+    buildId: z.ZodNullable<z.ZodString>;
+    instanceId: z.ZodString;
+    revisionId: z.ZodNullable<z.ZodUUID>;
+    model: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        error: "error";
+        completed: "completed";
+        "safety-stop": "safety-stop";
+        aborted: "aborted";
+    }>;
+    errorCode: z.ZodNullable<z.ZodEnum<{
+        model_error: "model_error";
+        pipeline_error: "pipeline_error";
+        budget_exhausted: "budget_exhausted";
+        step_limit: "step_limit";
+    }>>;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    cost: z.ZodObject<{
+        usd: z.ZodNullable<z.ZodNumber>;
+        source: z.ZodNullable<z.ZodEnum<{
+            "provider-reported": "provider-reported";
+            "price-table": "price-table";
+        }>>;
+        pricingVersion: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    latency: z.ZodObject<{
+        firstTokenMs: z.ZodNullable<z.ZodNumber>;
+        totalMs: z.ZodNumber;
+    }, z.core.$strict>;
+    toolCallCount: z.ZodNumber;
+    toolErrorCount: z.ZodNumber;
+    tools: z.ZodArray<z.ZodObject<{
+        toolId: z.ZodUUID;
+        calls: z.ZodNumber;
+        errors: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    eventId: z.ZodUUID;
+    eventType: z.ZodLiteral<"tool_contract_rejected">;
+    occurredAt: z.ZodISODateTime;
+    appId: z.ZodUUID;
+    environmentId: z.ZodUUID;
+    buildId: z.ZodNullable<z.ZodString>;
+    instanceId: z.ZodString;
+    revisionId: z.ZodNullable<z.ZodUUID>;
+    toolId: z.ZodUUID;
+    inputSchemaDigest: z.ZodString;
+    httpStatus: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<422>]>;
+}, z.core.$strict>], "eventType">;
+export type RuntimeMetricEvent = z.infer<typeof RuntimeMetricEventSchema>;
+/**
+ * Body of `POST /v1/runtime/apps/:appId/environments/:environmentId/metrics/events`.
+ * One batch carries one event type, so a Platform that does not know a newer
+ * type refuses only that batch and keeps receiving turns.
+ */
+export declare const TechnicalRuntimeEventBatchSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        eventId: z.ZodUUID;
+        eventType: z.ZodLiteral<"turn.finished">;
+        occurredAt: z.ZodISODateTime;
+        appId: z.ZodUUID;
+        environmentId: z.ZodUUID;
+        buildId: z.ZodNullable<z.ZodString>;
+        instanceId: z.ZodString;
+        revisionId: z.ZodNullable<z.ZodUUID>;
+        model: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            error: "error";
+            completed: "completed";
+            "safety-stop": "safety-stop";
+            aborted: "aborted";
+        }>;
+        errorCode: z.ZodNullable<z.ZodEnum<{
+            model_error: "model_error";
+            pipeline_error: "pipeline_error";
+            budget_exhausted: "budget_exhausted";
+            step_limit: "step_limit";
+        }>>;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cost: z.ZodObject<{
+            usd: z.ZodNullable<z.ZodNumber>;
+            source: z.ZodNullable<z.ZodEnum<{
+                "provider-reported": "provider-reported";
+                "price-table": "price-table";
+            }>>;
+            pricingVersion: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        latency: z.ZodObject<{
+            firstTokenMs: z.ZodNullable<z.ZodNumber>;
+            totalMs: z.ZodNumber;
+        }, z.core.$strict>;
+        toolCallCount: z.ZodNumber;
+        toolErrorCount: z.ZodNumber;
+        tools: z.ZodArray<z.ZodObject<{
+            toolId: z.ZodUUID;
+            calls: z.ZodNumber;
+            errors: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        eventId: z.ZodUUID;
+        eventType: z.ZodLiteral<"tool_contract_rejected">;
+        occurredAt: z.ZodISODateTime;
+        appId: z.ZodUUID;
+        environmentId: z.ZodUUID;
+        buildId: z.ZodNullable<z.ZodString>;
+        instanceId: z.ZodString;
+        revisionId: z.ZodNullable<z.ZodUUID>;
+        toolId: z.ZodUUID;
+        inputSchemaDigest: z.ZodString;
+        httpStatus: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<422>]>;
+    }, z.core.$strict>], "eventType">>;
+}, z.core.$strict>;
+export type TechnicalRuntimeEventBatch = z.infer<typeof TechnicalRuntimeEventBatchSchema>;

package/dist/cjs/contracts/events.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TechnicalRuntimeEventBatchSchema = exports.RuntimeMetricEventSchema = exports.ToolContractRejectedEventSchema = exports.TOOL_CONTRACT_REJECTED_STATUSES = exports.TechnicalRuntimeEventV2Schema = exports.RuntimeTurnToolUsageSchema = exports.RuntimeTurnCostSchema = exports.RuntimeCostSourceSchema = exports.RuntimeTurnErrorCodeSchema = exports.RuntimeTurnStatusSchema = exports.RUNTIME_PRICING_VERSION_PATTERN = exports.RUNTIME_METRIC_LABEL_PATTERN = exports.RUNTIME_METRIC_MAX_COUNT = exports.RUNTIME_METRIC_MAX_TOOLS = exports.RUNTIME_METRIC_MAX_BATCH = exports.RUNTIME_METRIC_EVENT_SCHEMA_VERSION = exports.TechnicalRuntimeEventSchema = void 0;
+const zod_1 = require("zod");
+const content_boundary_js_1 = require("./content-boundary.js");
+exports.TechnicalRuntimeEventSchema = zod_1.z.object({
+    eventId: zod_1.z.uuid(),
+    occurredAt: zod_1.z.iso.datetime({ offset: true }),
+    eventType: zod_1.z.string().trim().min(1).max(100),
+    tenantId: zod_1.z.uuid(),
+    targetAppId: zod_1.z.uuid(),
+    environmentId: zod_1.z.uuid(),
+    agentRevisionId: zod_1.z.uuid().optional(),
+    policyRevisionId: zod_1.z.uuid().optional(),
+    manifestRevisionId: zod_1.z.uuid().optional(),
+    runId: zod_1.z.string().trim().min(1).max(200),
+    status: zod_1.z.string().trim().min(1).max(100),
+    durationMs: zod_1.z.number().int().nonnegative().optional(),
+    errorClass: zod_1.z.string().trim().min(1).max(200).optional(),
+    budget: zod_1.z.object({
+        modelSteps: zod_1.z.number().int().nonnegative(),
+        toolCalls: zod_1.z.number().int().nonnegative(),
+        inputTokens: zod_1.z.number().int().nonnegative(),
+        outputTokens: zod_1.z.number().int().nonnegative(),
+        estimatedCostUsd: zod_1.z.number().finite().nonnegative().optional(),
+    }).strict().optional(),
+    metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).default({}),
+}).strict().superRefine((event, context) => {
+    const path = (0, content_boundary_js_1.findForbiddenContentPath)(event.metadata, ['metadata']);
+    if (path) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Technical runtime events must not contain business content or credentials',
+            path,
+        });
+    }
+});
+// ---------------------------------------------------------------------------
+// TechnicalRuntimeEvent v2: one content-free metric event per chat turn
+// ---------------------------------------------------------------------------
+exports.RUNTIME_METRIC_EVENT_SCHEMA_VERSION = 2;
+/** Most events one ingest request carries (keeps a batch far below 256 KB). */
+exports.RUNTIME_METRIC_MAX_BATCH = 50;
+/** Most distinct tools one turn event lists; further tools only count. */
+exports.RUNTIME_METRIC_MAX_TOOLS = 32;
+/** Largest count or token number a metric carries (Postgres `integer`). */
+exports.RUNTIME_METRIC_MAX_COUNT = 2_147_483_647;
+/**
+ * A technical label (model slug, build id, instance id): no whitespace, no
+ * quotes, at most 200 characters. Free text cannot pass.
+ */
+exports.RUNTIME_METRIC_LABEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/@+-]{0,199}$/;
+exports.RUNTIME_PRICING_VERSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/;
+const metricLabel = zod_1.z.string().regex(exports.RUNTIME_METRIC_LABEL_PATTERN);
+const metricCount = zod_1.z.number().int().nonnegative().max(exports.RUNTIME_METRIC_MAX_COUNT);
+const callCount = zod_1.z.number().int().nonnegative().max(10_000);
+const durationMs = zod_1.z.number().int().nonnegative().max(86_400_000);
+exports.RuntimeTurnStatusSchema = zod_1.z.enum([
+    'completed',
+    'safety-stop',
+    'aborted',
+    'error',
+]);
+exports.RuntimeTurnErrorCodeSchema = zod_1.z.enum([
+    'model_error',
+    'pipeline_error',
+    'budget_exhausted',
+    'step_limit',
+]);
+exports.RuntimeCostSourceSchema = zod_1.z.enum(['provider-reported', 'price-table']);
+const ERROR_CODES_BY_STATUS = {
+    error: ['model_error', 'pipeline_error'],
+    'safety-stop': ['budget_exhausted', 'step_limit'],
+};
+/**
+ * Cost of a turn with its provenance. Unknown stays `null`, never 0: a
+ * provider-reported amount (OpenRouter `usage.cost`) or a price-table
+ * estimate that names its pricing version.
+ */
+exports.RuntimeTurnCostSchema = zod_1.z.object({
+    usd: zod_1.z.number().finite().nonnegative().max(1_000_000).nullable(),
+    source: exports.RuntimeCostSourceSchema.nullable(),
+    pricingVersion: zod_1.z.string().regex(exports.RUNTIME_PRICING_VERSION_PATTERN).nullable(),
+}).strict().superRefine((cost, context) => {
+    if ((cost.usd === null) !== (cost.source === null)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'A cost amount and its source are known together or not at all',
+            path: ['source'],
+        });
+    }
+    if ((cost.source === 'price-table') !== (cost.pricingVersion !== null)) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Exactly a price-table cost names its pricing version',
+            path: ['pricingVersion'],
+        });
+    }
+});
+exports.RuntimeTurnToolUsageSchema = zod_1.z.object({
+    toolId: zod_1.z.uuid(),
+    calls: callCount.min(1),
+    errors: callCount,
+}).strict().refine((usage) => usage.errors <= usage.calls, {
+    message: 'A tool cannot fail more often than it was called',
+    path: ['errors'],
+});
+exports.TechnicalRuntimeEventV2Schema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal(exports.RUNTIME_METRIC_EVENT_SCHEMA_VERSION),
+    eventId: zod_1.z.uuid(),
+    eventType: zod_1.z.literal('turn.finished'),
+    occurredAt: zod_1.z.iso.datetime({ offset: true }),
+    appId: zod_1.z.uuid(),
+    environmentId: zod_1.z.uuid(),
+    buildId: metricLabel.nullable(),
+    instanceId: metricLabel,
+    revisionId: zod_1.z.uuid().nullable(),
+    model: metricLabel.nullable(),
+    status: exports.RuntimeTurnStatusSchema,
+    errorCode: exports.RuntimeTurnErrorCodeSchema.nullable(),
+    inputTokens: metricCount,
+    outputTokens: metricCount,
+    cost: exports.RuntimeTurnCostSchema,
+    latency: zod_1.z.object({
+        firstTokenMs: durationMs.nullable(),
+        totalMs: durationMs,
+    }).strict(),
+    toolCallCount: callCount,
+    toolErrorCount: callCount,
+    tools: zod_1.z.array(exports.RuntimeTurnToolUsageSchema).max(exports.RUNTIME_METRIC_MAX_TOOLS),
+}).strict().superRefine((event, context) => {
+    const allowed = ERROR_CODES_BY_STATUS[event.status];
+    if (allowed ? !event.errorCode || !allowed.includes(event.errorCode) : event.errorCode !== null) {
+        context.addIssue({
+            code: 'custom',
+            message: 'The error code does not match the turn status',
+            path: ['errorCode'],
+        });
+    }
+    if (event.latency.firstTokenMs !== null
+        && event.latency.firstTokenMs > event.latency.totalMs) {
+        context.addIssue({
+            code: 'custom',
+            message: 'The first token cannot arrive after the turn ended',
+            path: ['latency', 'firstTokenMs'],
+        });
+    }
+    if (event.toolErrorCount > event.toolCallCount) {
+        context.addIssue({
+            code: 'custom',
+            message: 'A turn cannot have more failed than started tool calls',
+            path: ['toolErrorCount'],
+        });
+    }
+    const toolIds = event.tools.map((tool) => tool.toolId);
+    if (new Set(toolIds).size !== toolIds.length) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Each tool is listed once',
+            path: ['tools'],
+        });
+    }
+    const listedCalls = event.tools.reduce((sum, tool) => sum + tool.calls, 0);
+    const listedErrors = event.tools.reduce((sum, tool) => sum + tool.errors, 0);
+    if (listedCalls > event.toolCallCount || listedErrors > event.toolErrorCount) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Listed tools cannot exceed the turn totals',
+            path: ['tools'],
+        });
+    }
+    const forbidden = (0, content_boundary_js_1.findForbiddenPlatformContentPath)(event);
+    if (forbidden) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Runtime metric events must not contain content or credentials',
+            path: forbidden,
+        });
+    }
+});
+/** Statuses of an endpoint that refused a call its tool schema accepted. */
+exports.TOOL_CONTRACT_REJECTED_STATUSES = [400, 422];
+/**
+ * An endpoint refused a call that passed the tool's input schema (spec 4.7):
+ * the contract the model saw is wrong, so the tool belongs on the next work
+ * list or managed job. Content-free: tool, schema version and status, never
+ * arguments, response or message.
+ */
+exports.ToolContractRejectedEventSchema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal(exports.RUNTIME_METRIC_EVENT_SCHEMA_VERSION),
+    eventId: zod_1.z.uuid(),
+    eventType: zod_1.z.literal('tool_contract_rejected'),
+    occurredAt: zod_1.z.iso.datetime({ offset: true }),
+    appId: zod_1.z.uuid(),
+    environmentId: zod_1.z.uuid(),
+    buildId: metricLabel.nullable(),
+    instanceId: metricLabel,
+    revisionId: zod_1.z.uuid().nullable(),
+    toolId: zod_1.z.uuid(),
+    /** The manifest's digest of the input schema the call passed (same alphabet as the manifest). */
+    inputSchemaDigest: zod_1.z.string().regex(/^sha256:[A-Za-z0-9+/=_-]{1,88}$/),
+    httpStatus: zod_1.z.union([zod_1.z.literal(400), zod_1.z.literal(422)]),
+}).strict().superRefine((event, context) => {
+    const forbidden = (0, content_boundary_js_1.findForbiddenPlatformContentPath)(event);
+    if (forbidden) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Runtime metric events must not contain content or credentials',
+            path: forbidden,
+        });
+    }
+});
+/** Every content-free metric event of the runtime: finished turns and contract rejections. */
+exports.RuntimeMetricEventSchema = zod_1.z.discriminatedUnion('eventType', [
+    exports.TechnicalRuntimeEventV2Schema,
+    exports.ToolContractRejectedEventSchema,
+]);
+/**
+ * Body of `POST /v1/runtime/apps/:appId/environments/:environmentId/metrics/events`.
+ * One batch carries one event type, so a Platform that does not know a newer
+ * type refuses only that batch and keeps receiving turns.
+ */
+exports.TechnicalRuntimeEventBatchSchema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal(exports.RUNTIME_METRIC_EVENT_SCHEMA_VERSION),
+    events: zod_1.z.array(exports.RuntimeMetricEventSchema).min(1).max(exports.RUNTIME_METRIC_MAX_BATCH),
+}).strict().refine((batch) => new Set(batch.events.map((event) => event.eventType)).size === 1, {
+    message: 'A batch carries one event type',
+    path: ['events'],
+});

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

@@ -0,0 +1,18 @@
+export { DelegationBudgetSchema, ExecutionBudgetSchema, PrincipalSchema, PromptPinSchema, RuntimeEnvironmentNameSchema, RuntimeEnvironmentSchema, } from './runtime.js';
+export type { DelegationBudget, ExecutionBudget, Principal, PromptPin, RuntimeEnvironment, } from './runtime.js';
+export { AgentRevisionSchema, ExecutionLeaseSchema, LocalBindingReferenceSchema, ManifestRevisionSchema, ManifestToolSchema, ToolPresentationSchema, RevisionSignatureSchema, RuntimeRevisionEnvelopeSchema, RuntimeDeploymentBundleSchema, RuntimeSyncBundleSchema, RuntimePolicyRevisionSchema, RuntimeToolPolicySchema, SecurityRevocationSchema, ToolRiskClassSchema, } from './revisions.js';
+export type { AgentRevision, ExecutionLease, LocalBindingReference, ManifestRevision, ManifestTool, RevisionSignature, RuntimeRevisionEnvelope, RuntimeDeploymentBundle, RuntimeSyncBundle, RuntimePolicyRevision, RuntimeToolPolicy, SecurityRevocation, ToolPresentation, ToolRiskClass, } from './revisions.js';
+export { RUNTIME_METRIC_EVENT_SCHEMA_VERSION, RUNTIME_METRIC_LABEL_PATTERN, RUNTIME_METRIC_MAX_BATCH, RUNTIME_METRIC_MAX_COUNT, RUNTIME_METRIC_MAX_TOOLS, RUNTIME_PRICING_VERSION_PATTERN, RuntimeCostSourceSchema, RuntimeTurnCostSchema, RuntimeTurnErrorCodeSchema, RuntimeTurnStatusSchema, RuntimeTurnToolUsageSchema, RuntimeMetricEventSchema, TechnicalRuntimeEventBatchSchema, TechnicalRuntimeEventSchema, TechnicalRuntimeEventV2Schema, TOOL_CONTRACT_REJECTED_STATUSES, ToolContractRejectedEventSchema, } from './events.js';
+export type { RuntimeCostSource, RuntimeMetricEvent, ToolContractRejectedEvent, RuntimeTurnCost, RuntimeTurnErrorCode, RuntimeTurnStatus, RuntimeTurnToolUsage, TechnicalRuntimeEvent, TechnicalRuntimeEventBatch, TechnicalRuntimeEventV2, } from './events.js';
+export { APP_SETUP_EXCLUSION_LIMITS, AppSetupArtifactSchema, AppSetupAssessmentModeSchema, AppSetupExclusionSchema, AppSetupOperationGroupSchema, AppSetupStatusSchema, AppSetupToolCandidateSchema, AppSetupToolProvenanceSchema, assertAppSetupSemanticParity, } from './app-setup.js';
+export { classifyToolSemanticChange } from './semantic-change.js';
+export type { SemanticChange, SemanticChangeClassification, ToolSemanticState, } from './semantic-change.js';
+export { TOOL_POLICY_RULES_VERSION, ToolOverrideDeltaSchema, ToolPolicyEntrySchema, ToolPolicyFileSchema, ToolPolicyPinSchema, confirmationFloor, confirmationRelaxationOutcome, deriveToolPolicyDefaults, intersectAllowedRoles, mostRestrictiveRiskClass, parseToolPolicyFile, platformMayRelaxConfirmation, resolveToolPolicy, riskTier, } from './tool-policy.js';
+export type { AllowedRolesIntersection, ConfirmationRelaxationOutcome, DeclaredEffect, EffectiveToolPolicy, PolicyOrigin, ResolveToolPolicyInput, ResolveToolPolicyResult, RiskTier, ToolPolicyDefaults, ToolPolicyDefaultsInput, ToolOverrideDelta, ToolPolicyEntry, ToolPolicyFile, ToolPolicyWarningCode, } from './tool-policy.js';
+export type { AppSetupArtifact, AppSetupAssessmentMode, AppSetupExclusion, AppSetupOperationGroup, AppSetupStatus, AppSetupToolCandidate, AppSetupToolProvenance, } from './app-setup.js';
+export { canonicalPromptBundleJson, PromptBundleSchema, PromptRevisionMetadataSchema, SignedPromptBindingSchema, } from './prompt-bundle.js';
+export type { PromptBundle, PromptRevisionMetadata, SignedPromptBinding, } from './prompt-bundle.js';
+export { PlatformPromptRevisionSchema, } from './platform-prompt-revision.js';
+export type { PlatformPromptRevision, } from './platform-prompt-revision.js';
+export { PairingStartRequestSchema, PairingStartResponseSchema, PairingTokenResultSchema, PlatformConnectionDescriptorSchema, } from './platform-connection.js';
+export type { PairingStartRequest, PairingStartResponse, PairingTokenResult, PlatformConnectionDescriptor, } from './platform-connection.js';

package/dist/cjs/contracts/index.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolPolicyEntrySchema = exports.ToolOverrideDeltaSchema = exports.TOOL_POLICY_RULES_VERSION = exports.classifyToolSemanticChange = exports.assertAppSetupSemanticParity = exports.AppSetupToolProvenanceSchema = exports.AppSetupToolCandidateSchema = exports.AppSetupStatusSchema = exports.AppSetupOperationGroupSchema = exports.AppSetupExclusionSchema = exports.AppSetupAssessmentModeSchema = exports.AppSetupArtifactSchema = exports.APP_SETUP_EXCLUSION_LIMITS = exports.ToolContractRejectedEventSchema = exports.TOOL_CONTRACT_REJECTED_STATUSES = exports.TechnicalRuntimeEventV2Schema = exports.TechnicalRuntimeEventSchema = exports.TechnicalRuntimeEventBatchSchema = exports.RuntimeMetricEventSchema = exports.RuntimeTurnToolUsageSchema = exports.RuntimeTurnStatusSchema = exports.RuntimeTurnErrorCodeSchema = exports.RuntimeTurnCostSchema = exports.RuntimeCostSourceSchema = exports.RUNTIME_PRICING_VERSION_PATTERN = exports.RUNTIME_METRIC_MAX_TOOLS = exports.RUNTIME_METRIC_MAX_COUNT = exports.RUNTIME_METRIC_MAX_BATCH = exports.RUNTIME_METRIC_LABEL_PATTERN = exports.RUNTIME_METRIC_EVENT_SCHEMA_VERSION = exports.ToolRiskClassSchema = exports.SecurityRevocationSchema = exports.RuntimeToolPolicySchema = exports.RuntimePolicyRevisionSchema = exports.RuntimeSyncBundleSchema = exports.RuntimeDeploymentBundleSchema = exports.RuntimeRevisionEnvelopeSchema = exports.RevisionSignatureSchema = exports.ToolPresentationSchema = exports.ManifestToolSchema = exports.ManifestRevisionSchema = exports.LocalBindingReferenceSchema = exports.ExecutionLeaseSchema = exports.AgentRevisionSchema = exports.RuntimeEnvironmentSchema = exports.RuntimeEnvironmentNameSchema = exports.PromptPinSchema = exports.PrincipalSchema = exports.ExecutionBudgetSchema = exports.DelegationBudgetSchema = void 0;
+exports.PlatformConnectionDescriptorSchema = exports.PairingTokenResultSchema = exports.PairingStartResponseSchema = exports.PairingStartRequestSchema = exports.PlatformPromptRevisionSchema = exports.SignedPromptBindingSchema = exports.PromptRevisionMetadataSchema = exports.PromptBundleSchema = exports.canonicalPromptBundleJson = exports.riskTier = exports.resolveToolPolicy = exports.platformMayRelaxConfirmation = exports.parseToolPolicyFile = exports.mostRestrictiveRiskClass = exports.intersectAllowedRoles = exports.deriveToolPolicyDefaults = exports.confirmationRelaxationOutcome = exports.confirmationFloor = exports.ToolPolicyPinSchema = exports.ToolPolicyFileSchema = void 0;
+var runtime_js_1 = require("./runtime.js");
+Object.defineProperty(exports, "DelegationBudgetSchema", { enumerable: true, get: function () { return runtime_js_1.DelegationBudgetSchema; } });
+Object.defineProperty(exports, "ExecutionBudgetSchema", { enumerable: true, get: function () { return runtime_js_1.ExecutionBudgetSchema; } });
+Object.defineProperty(exports, "PrincipalSchema", { enumerable: true, get: function () { return runtime_js_1.PrincipalSchema; } });
+Object.defineProperty(exports, "PromptPinSchema", { enumerable: true, get: function () { return runtime_js_1.PromptPinSchema; } });
+Object.defineProperty(exports, "RuntimeEnvironmentNameSchema", { enumerable: true, get: function () { return runtime_js_1.RuntimeEnvironmentNameSchema; } });
+Object.defineProperty(exports, "RuntimeEnvironmentSchema", { enumerable: true, get: function () { return runtime_js_1.RuntimeEnvironmentSchema; } });
+var revisions_js_1 = require("./revisions.js");
+Object.defineProperty(exports, "AgentRevisionSchema", { enumerable: true, get: function () { return revisions_js_1.AgentRevisionSchema; } });
+Object.defineProperty(exports, "ExecutionLeaseSchema", { enumerable: true, get: function () { return revisions_js_1.ExecutionLeaseSchema; } });
+Object.defineProperty(exports, "LocalBindingReferenceSchema", { enumerable: true, get: function () { return revisions_js_1.LocalBindingReferenceSchema; } });
+Object.defineProperty(exports, "ManifestRevisionSchema", { enumerable: true, get: function () { return revisions_js_1.ManifestRevisionSchema; } });
+Object.defineProperty(exports, "ManifestToolSchema", { enumerable: true, get: function () { return revisions_js_1.ManifestToolSchema; } });
+Object.defineProperty(exports, "ToolPresentationSchema", { enumerable: true, get: function () { return revisions_js_1.ToolPresentationSchema; } });
+Object.defineProperty(exports, "RevisionSignatureSchema", { enumerable: true, get: function () { return revisions_js_1.RevisionSignatureSchema; } });
+Object.defineProperty(exports, "RuntimeRevisionEnvelopeSchema", { enumerable: true, get: function () { return revisions_js_1.RuntimeRevisionEnvelopeSchema; } });
+Object.defineProperty(exports, "RuntimeDeploymentBundleSchema", { enumerable: true, get: function () { return revisions_js_1.RuntimeDeploymentBundleSchema; } });
+Object.defineProperty(exports, "RuntimeSyncBundleSchema", { enumerable: true, get: function () { return revisions_js_1.RuntimeSyncBundleSchema; } });
+Object.defineProperty(exports, "RuntimePolicyRevisionSchema", { enumerable: true, get: function () { return revisions_js_1.RuntimePolicyRevisionSchema; } });
+Object.defineProperty(exports, "RuntimeToolPolicySchema", { enumerable: true, get: function () { return revisions_js_1.RuntimeToolPolicySchema; } });
+Object.defineProperty(exports, "SecurityRevocationSchema", { enumerable: true, get: function () { return revisions_js_1.SecurityRevocationSchema; } });
+Object.defineProperty(exports, "ToolRiskClassSchema", { enumerable: true, get: function () { return revisions_js_1.ToolRiskClassSchema; } });
+var events_js_1 = require("./events.js");
+Object.defineProperty(exports, "RUNTIME_METRIC_EVENT_SCHEMA_VERSION", { enumerable: true, get: function () { return events_js_1.RUNTIME_METRIC_EVENT_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "RUNTIME_METRIC_LABEL_PATTERN", { enumerable: true, get: function () { return events_js_1.RUNTIME_METRIC_LABEL_PATTERN; } });
+Object.defineProperty(exports, "RUNTIME_METRIC_MAX_BATCH", { enumerable: true, get: function () { return events_js_1.RUNTIME_METRIC_MAX_BATCH; } });
+Object.defineProperty(exports, "RUNTIME_METRIC_MAX_COUNT", { enumerable: true, get: function () { return events_js_1.RUNTIME_METRIC_MAX_COUNT; } });
+Object.defineProperty(exports, "RUNTIME_METRIC_MAX_TOOLS", { enumerable: true, get: function () { return events_js_1.RUNTIME_METRIC_MAX_TOOLS; } });
+Object.defineProperty(exports, "RUNTIME_PRICING_VERSION_PATTERN", { enumerable: true, get: function () { return events_js_1.RUNTIME_PRICING_VERSION_PATTERN; } });
+Object.defineProperty(exports, "RuntimeCostSourceSchema", { enumerable: true, get: function () { return events_js_1.RuntimeCostSourceSchema; } });
+Object.defineProperty(exports, "RuntimeTurnCostSchema", { enumerable: true, get: function () { return events_js_1.RuntimeTurnCostSchema; } });
+Object.defineProperty(exports, "RuntimeTurnErrorCodeSchema", { enumerable: true, get: function () { return events_js_1.RuntimeTurnErrorCodeSchema; } });
+Object.defineProperty(exports, "RuntimeTurnStatusSchema", { enumerable: true, get: function () { return events_js_1.RuntimeTurnStatusSchema; } });
+Object.defineProperty(exports, "RuntimeTurnToolUsageSchema", { enumerable: true, get: function () { return events_js_1.RuntimeTurnToolUsageSchema; } });
+Object.defineProperty(exports, "RuntimeMetricEventSchema", { enumerable: true, get: function () { return events_js_1.RuntimeMetricEventSchema; } });
+Object.defineProperty(exports, "TechnicalRuntimeEventBatchSchema", { enumerable: true, get: function () { return events_js_1.TechnicalRuntimeEventBatchSchema; } });
+Object.defineProperty(exports, "TechnicalRuntimeEventSchema", { enumerable: true, get: function () { return events_js_1.TechnicalRuntimeEventSchema; } });
+Object.defineProperty(exports, "TechnicalRuntimeEventV2Schema", { enumerable: true, get: function () { return events_js_1.TechnicalRuntimeEventV2Schema; } });
+Object.defineProperty(exports, "TOOL_CONTRACT_REJECTED_STATUSES", { enumerable: true, get: function () { return events_js_1.TOOL_CONTRACT_REJECTED_STATUSES; } });
+Object.defineProperty(exports, "ToolContractRejectedEventSchema", { enumerable: true, get: function () { return events_js_1.ToolContractRejectedEventSchema; } });
+var app_setup_js_1 = require("./app-setup.js");
+Object.defineProperty(exports, "APP_SETUP_EXCLUSION_LIMITS", { enumerable: true, get: function () { return app_setup_js_1.APP_SETUP_EXCLUSION_LIMITS; } });
+Object.defineProperty(exports, "AppSetupArtifactSchema", { enumerable: true, get: function () { return app_setup_js_1.AppSetupArtifactSchema; } });
+Object.defineProperty(exports, "AppSetupAssessmentModeSchema", { enumerable: true, get: function () { return app_setup_js_1.AppSetupAssessmentModeSchema; } });
+Object.defineProperty(exports, "AppSetupExclusionSchema", { enumerable: true, get: function () { return app_setup_js_1.AppSetupExclusionSchema; } });
+Object.defineProperty(exports, "AppSetupOperationGroupSchema", { enumerable: true, get: function () { return app_setup_js_1.AppSetupOperationGroupSchema; } });
+Object.defineProperty(exports, "AppSetupStatusSchema", { enumerable: true, get: function () { return app_setup_js_1.AppSetupStatusSchema; } });
+Object.defineProperty(exports, "AppSetupToolCandidateSchema", { enumerable: true, get: function () { return app_setup_js_1.AppSetupToolCandidateSchema; } });
+Object.defineProperty(exports, "AppSetupToolProvenanceSchema", { enumerable: true, get: function () { return app_setup_js_1.AppSetupToolProvenanceSchema; } });
+Object.defineProperty(exports, "assertAppSetupSemanticParity", { enumerable: true, get: function () { return app_setup_js_1.assertAppSetupSemanticParity; } });
+var semantic_change_js_1 = require("./semantic-change.js");
+Object.defineProperty(exports, "classifyToolSemanticChange", { enumerable: true, get: function () { return semantic_change_js_1.classifyToolSemanticChange; } });
+var tool_policy_js_1 = require("./tool-policy.js");
+Object.defineProperty(exports, "TOOL_POLICY_RULES_VERSION", { enumerable: true, get: function () { return tool_policy_js_1.TOOL_POLICY_RULES_VERSION; } });
+Object.defineProperty(exports, "ToolOverrideDeltaSchema", { enumerable: true, get: function () { return tool_policy_js_1.ToolOverrideDeltaSchema; } });
+Object.defineProperty(exports, "ToolPolicyEntrySchema", { enumerable: true, get: function () { return tool_policy_js_1.ToolPolicyEntrySchema; } });
+Object.defineProperty(exports, "ToolPolicyFileSchema", { enumerable: true, get: function () { return tool_policy_js_1.ToolPolicyFileSchema; } });
+Object.defineProperty(exports, "ToolPolicyPinSchema", { enumerable: true, get: function () { return tool_policy_js_1.ToolPolicyPinSchema; } });
+Object.defineProperty(exports, "confirmationFloor", { enumerable: true, get: function () { return tool_policy_js_1.confirmationFloor; } });
+Object.defineProperty(exports, "confirmationRelaxationOutcome", { enumerable: true, get: function () { return tool_policy_js_1.confirmationRelaxationOutcome; } });
+Object.defineProperty(exports, "deriveToolPolicyDefaults", { enumerable: true, get: function () { return tool_policy_js_1.deriveToolPolicyDefaults; } });
+Object.defineProperty(exports, "intersectAllowedRoles", { enumerable: true, get: function () { return tool_policy_js_1.intersectAllowedRoles; } });
+Object.defineProperty(exports, "mostRestrictiveRiskClass", { enumerable: true, get: function () { return tool_policy_js_1.mostRestrictiveRiskClass; } });
+Object.defineProperty(exports, "parseToolPolicyFile", { enumerable: true, get: function () { return tool_policy_js_1.parseToolPolicyFile; } });
+Object.defineProperty(exports, "platformMayRelaxConfirmation", { enumerable: true, get: function () { return tool_policy_js_1.platformMayRelaxConfirmation; } });
+Object.defineProperty(exports, "resolveToolPolicy", { enumerable: true, get: function () { return tool_policy_js_1.resolveToolPolicy; } });
+Object.defineProperty(exports, "riskTier", { enumerable: true, get: function () { return tool_policy_js_1.riskTier; } });
+var prompt_bundle_js_1 = require("./prompt-bundle.js");
+Object.defineProperty(exports, "canonicalPromptBundleJson", { enumerable: true, get: function () { return prompt_bundle_js_1.canonicalPromptBundleJson; } });
+Object.defineProperty(exports, "PromptBundleSchema", { enumerable: true, get: function () { return prompt_bundle_js_1.PromptBundleSchema; } });
+Object.defineProperty(exports, "PromptRevisionMetadataSchema", { enumerable: true, get: function () { return prompt_bundle_js_1.PromptRevisionMetadataSchema; } });
+Object.defineProperty(exports, "SignedPromptBindingSchema", { enumerable: true, get: function () { return prompt_bundle_js_1.SignedPromptBindingSchema; } });
+var platform_prompt_revision_js_1 = require("./platform-prompt-revision.js");
+Object.defineProperty(exports, "PlatformPromptRevisionSchema", { enumerable: true, get: function () { return platform_prompt_revision_js_1.PlatformPromptRevisionSchema; } });
+var platform_connection_js_1 = require("./platform-connection.js");
+Object.defineProperty(exports, "PairingStartRequestSchema", { enumerable: true, get: function () { return platform_connection_js_1.PairingStartRequestSchema; } });
+Object.defineProperty(exports, "PairingStartResponseSchema", { enumerable: true, get: function () { return platform_connection_js_1.PairingStartResponseSchema; } });
+Object.defineProperty(exports, "PairingTokenResultSchema", { enumerable: true, get: function () { return platform_connection_js_1.PairingTokenResultSchema; } });
+Object.defineProperty(exports, "PlatformConnectionDescriptorSchema", { enumerable: true, get: function () { return platform_connection_js_1.PlatformConnectionDescriptorSchema; } });

package/dist/cjs/contracts/plan.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Wire protocol between the built-in `update_plan` tool and the chat UI.
+ * Dependency-free so both the React bundle and the server adapters can
+ * import it without pulling in Zod.
+ */
+export declare const PLAN_TOOL_NAME: "update_plan";
+export declare const PLAN_ITEM_STATUSES: readonly ["pending", "in_progress", "completed"];
+export type PlanItemStatus = (typeof PLAN_ITEM_STATUSES)[number];
+/** Shared by the server tool schema and the chat UI reader. */
+export declare const PLAN_MAX_ITEMS = 12;
+export declare const PLAN_MAX_TITLE_LENGTH = 120;
+export interface PlanItem {
+    readonly title: string;
+    readonly status: PlanItemStatus;
+}
+/**
+ * Reads the items of an `update_plan` input, dropping malformed entries.
+ * Returns null when the input carries no item list at all.
+ */
+export declare function readPlanItems(input: unknown): PlanItem[] | null;