@rynx-ai/workspace 0.1.9

package/dist/device-protocol.d.ts

@@ -0,0 +1,322 @@
+import type { WorkspaceDevice, WorkspaceDeviceIdentity, WorkspaceDeviceInventory, WorkspaceDeviceSkillArtifactBundle, WorkspaceDeviceSkillRuntimeImportReport, WorkspaceDeviceSkillRuntimeImportTask, WorkspaceDeviceSkillRuntimeScanReport, WorkspaceDeviceSkillRuntimeScanTask, WorkspaceRepositoryScanResult } from "./types.js";
+import type { WorkspaceAgentExecutionSpecV1, WorkspaceAgentInteractionResolution } from "./agent-execution.js";
+import type { WorkspaceAgentRuntimeId } from "./agent-options.js";
+export declare const WORKSPACE_DEVICE_PROTOCOL_VERSION: 5;
+export declare const WORKSPACE_DEVICE_WS_PATH = "/api/device-connection";
+export declare const WORKSPACE_INSTALLATION_PROOF_ALGORITHM: "Ed25519";
+export declare const WORKSPACE_INSTALLATION_PROOF_PLUGIN_ID: "workspace";
+export declare const WORKSPACE_INSTALLATION_PROOF_DOMAIN: "rynx-plugin-installation-proof-v1";
+export declare const WORKSPACE_DEVICE_PROOF_CONTEXT: "rynx-workspace-device-proof-v1";
+export declare const WORKSPACE_DEVICE_ACCESS_PROOF_CONTEXT: "rynx-workspace-device-access-proof-v1";
+export declare function workspaceInstallationProofChallenge(serverId: string, workspaceId: string, challenge: string): string;
+export declare function workspaceInstallationProofMessage(installationId: string, serverId: string, workspaceId: string, challenge: string): string;
+export declare function workspaceDeviceAccessProofChallenge(serverId: string, authorizationId: string, nonce: string): string;
+export declare function workspaceDeviceAccessProofMessage(installationId: string, serverId: string, authorizationId: string, nonce: string): string;
+export type WorkspaceDeviceTaskKind = "repository.inspect" | "skill.runtime.scan" | "skill.runtime.import";
+export interface WorkspaceRepositoryInspectPayload {
+    requestId: string;
+    path: string;
+}
+export type WorkspaceDeviceTaskPayload = {
+    kind: "repository.inspect";
+    value: WorkspaceRepositoryInspectPayload;
+} | {
+    kind: "skill.runtime.scan";
+    value: WorkspaceDeviceSkillRuntimeScanTask;
+} | {
+    kind: "skill.runtime.import";
+    value: WorkspaceDeviceSkillRuntimeImportTask;
+};
+export interface WorkspaceLeasedDeviceTask {
+    id: string;
+    kind: WorkspaceDeviceTaskKind;
+    payload: WorkspaceDeviceTaskPayload;
+    payloadHash: string;
+    attempt: number;
+    leaseToken: string;
+    leaseExpiresAt: string;
+}
+export type WorkspaceDeviceTaskCompletion = {
+    kind: "repository.inspect";
+    requestId: string;
+    repository?: WorkspaceRepositoryScanResult;
+    error?: string;
+} | {
+    kind: "skill.runtime.scan";
+    report: WorkspaceDeviceSkillRuntimeScanReport;
+} | {
+    kind: "skill.runtime.import";
+    report: WorkspaceDeviceSkillRuntimeImportReport;
+};
+export interface WorkspaceDeviceTaskResult {
+    taskId: string;
+    leaseToken: string;
+    resultHash: string;
+    completion: WorkspaceDeviceTaskCompletion;
+}
+export type WorkspaceTaskFinishDisposition = "committed" | "duplicate" | "stale" | "rejected" | "discarded";
+export interface WorkspaceDeviceHelloMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "device.hello";
+    instanceId: string;
+    installationId: string;
+    proof: {
+        algorithm: typeof WORKSPACE_INSTALLATION_PROOF_ALGORITHM;
+        publicKey: string;
+        challenge: string;
+        signature: string;
+    };
+    identity: WorkspaceDeviceIdentity;
+    inventoryDigest?: string;
+    capacity: number;
+}
+export interface WorkspaceDeviceChallengeMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "device.challenge";
+    challenge: string;
+    expiresAt: string;
+}
+export interface WorkspaceDeviceInventoryMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "inventory.snapshot";
+    requestId: string;
+    inventory: WorkspaceDeviceInventory;
+}
+export interface WorkspaceDeviceTaskAcceptedMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "task.accept";
+    taskId: string;
+    leaseToken: string;
+}
+export interface WorkspaceDeviceTaskRenewMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "task.renew";
+    taskId: string;
+    leaseToken: string;
+}
+export interface WorkspaceDeviceTaskCompleteMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "task.complete";
+    result: WorkspaceDeviceTaskResult;
+}
+export interface WorkspaceAgentCapacityMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.capacity";
+    maxConcurrentRuns: number;
+    activeRuns: number;
+    observedAt: string;
+}
+export interface WorkspaceAgentTurnOfferAcceptedMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.turn.offer.accept";
+    offerId: string;
+    permitId: string;
+    daemonInstanceId: string;
+}
+export type WorkspaceAgentTurnOfferBusyReason = "capacity" | "runtime_unavailable" | "shutting_down";
+export interface WorkspaceAgentTurnOfferBusyMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.turn.offer.busy";
+    offerId: string;
+    daemonInstanceId: string;
+    reason: WorkspaceAgentTurnOfferBusyReason;
+}
+export interface WorkspaceAgentTurnAssignAckMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.turn.assign.ack";
+    commandId: string;
+    attemptId: string;
+    assignmentEpoch: number;
+    leaseToken: string;
+    daemonInstanceId: string;
+    /** `rejected` is legal only when the Daemon can prove that no environment,
+     * native Session, or Turn injection side effect started. Any uncertain
+     * injection must be reported as `turn.execution_unknown` instead. */
+    disposition: "accepted" | "replayed" | "rejected";
+    error?: string;
+}
+export interface WorkspaceAgentAttemptLeaseRenewMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.attempt.lease.renew";
+    attemptId: string;
+    assignmentEpoch: number;
+    leaseToken: string;
+    daemonInstanceId: string;
+}
+export type WorkspaceAgentAttemptEventType = "environment.preparing" | "environment.ready" | "environment.failed" | "session.ready" | "turn.started" | "turn.progress" | "interaction.requested" | "interaction.resolved" | "interaction.cancelled" | "turn.completed" | "turn.failed" | "turn.execution_unknown";
+export interface WorkspaceAgentAttemptEventMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.attempt.event";
+    eventId: string;
+    eventSequence: number;
+    attemptId: string;
+    assignmentEpoch: number;
+    leaseToken: string;
+    daemonInstanceId: string;
+    eventType: WorkspaceAgentAttemptEventType;
+    data: Record<string, unknown>;
+    occurredAt: string;
+}
+/** One source of truth for both the WebSocket boundary and durable Run store. */
+export declare const WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS: {
+    readonly codeLength: 256;
+    readonly textLength: 16384;
+    readonly artifactCount: 256;
+    readonly artifactKeyLength: 256;
+    readonly interactionFieldCount: 64;
+    readonly interactionActionCount: 16;
+    readonly interactionOptionCount: 128;
+    readonly interactionContextItemBytes: number;
+    readonly interactionRequestBytes: number;
+};
+/**
+ * Validate and project daemon event data onto the product-visible allowlist.
+ * Native runtime payloads, paths, fences and identifiers must never pass this
+ * boundary merely because they are valid JSON.
+ */
+export declare function normalizeWorkspaceAgentAttemptEventData(eventType: WorkspaceAgentAttemptEventType, value: unknown): Record<string, unknown> | null;
+export interface WorkspaceAgentTurnCancelAckMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.turn.cancel.ack";
+    commandId: string;
+    attemptId: string;
+    assignmentEpoch: number;
+    leaseToken: string;
+    daemonInstanceId: string;
+    disposition: "cancelled" | "already_terminal" | "stale";
+}
+export interface WorkspaceAgentInteractionResolveAckMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.interaction.resolve.ack";
+    commandId: string;
+    requestId: string;
+    interactionId: string;
+    attemptId: string;
+    assignmentEpoch: number;
+    leaseToken: string;
+    daemonInstanceId: string;
+    disposition: "applied" | "already_resolved" | "not_found" | "invalid";
+    error?: string;
+}
+export type WorkspaceDeviceClientMessage = WorkspaceDeviceHelloMessage | WorkspaceDeviceInventoryMessage | WorkspaceDeviceTaskAcceptedMessage | WorkspaceDeviceTaskRenewMessage | WorkspaceDeviceTaskCompleteMessage | WorkspaceAgentCapacityMessage | WorkspaceAgentTurnOfferAcceptedMessage | WorkspaceAgentTurnOfferBusyMessage | WorkspaceAgentTurnAssignAckMessage | WorkspaceAgentAttemptLeaseRenewMessage | WorkspaceAgentAttemptEventMessage | WorkspaceAgentTurnCancelAckMessage | WorkspaceAgentInteractionResolveAckMessage;
+export interface WorkspaceDeviceReadyMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "device.ready";
+    connectionId: string;
+    device: WorkspaceDevice;
+    leaseMs: number;
+    pingMs: number;
+    credentialId: string;
+    credentialStatus: "active";
+}
+export interface WorkspaceDeviceInventoryAckMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "inventory.ack";
+    requestId: string;
+    digest: string;
+}
+export interface WorkspaceDeviceTaskDispatchMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "task.dispatch";
+    task: WorkspaceLeasedDeviceTask;
+}
+export interface WorkspaceDeviceTaskRenewedMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "task.renewed";
+    taskId: string;
+    leaseToken: string;
+    leaseExpiresAt: string;
+}
+export interface WorkspaceDeviceTaskCompleteAckMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "task.complete.ack";
+    taskId: string;
+    leaseToken: string;
+    disposition: WorkspaceTaskFinishDisposition;
+}
+export interface WorkspaceDeviceProtocolErrorMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "protocol.error";
+    code: string;
+    message: string;
+    fatal: boolean;
+    requestId?: string;
+}
+export interface WorkspaceAgentTurnOfferMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.turn.offer";
+    offerId: string;
+    runId: string;
+    turnId: string;
+    runtime: WorkspaceAgentRuntimeId;
+    model: string;
+    reasoningEffort?: string;
+    /** Relative validity from receipt; daemon scheduling must not trust wall-clock skew. */
+    ttlMs: number;
+    expiresAt: string;
+}
+export interface WorkspaceAgentTurnAssignMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.turn.assign";
+    commandId: string;
+    offerId: string;
+    permitId: string;
+    attemptId: string;
+    assignmentEpoch: number;
+    leaseToken: string;
+    /** Remaining relative lease duration for this delivery. Replays refresh it
+     * from the durable Attempt lease; it is not the original lease duration. */
+    leaseMs: number;
+    leaseExpiresAt: string;
+    spec: WorkspaceAgentExecutionSpecV1;
+}
+export interface WorkspaceAgentTurnCancelMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.turn.cancel";
+    commandId: string;
+    attemptId: string;
+    assignmentEpoch: number;
+    leaseToken: string;
+    reason: string;
+}
+export interface WorkspaceAgentInteractionResolveMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.interaction.resolve";
+    commandId: string;
+    requestId: string;
+    interactionId: string;
+    attemptId: string;
+    assignmentEpoch: number;
+    leaseToken: string;
+    resolution: WorkspaceAgentInteractionResolution;
+}
+export interface WorkspaceAgentAttemptLeaseRenewedMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.attempt.lease.renewed";
+    attemptId: string;
+    assignmentEpoch: number;
+    leaseToken: string;
+    disposition: "renewed" | "stale";
+    leaseMs: number;
+    leaseExpiresAt?: string;
+}
+export interface WorkspaceAgentAttemptEventAckMessage {
+    v: typeof WORKSPACE_DEVICE_PROTOCOL_VERSION;
+    type: "agent.attempt.event.ack";
+    eventId: string;
+    attemptId: string;
+    eventSequence: number;
+    disposition: "committed" | "duplicate" | "stale" | "rejected";
+}
+export type WorkspaceDeviceServerMessage = WorkspaceDeviceChallengeMessage | WorkspaceDeviceReadyMessage | WorkspaceDeviceInventoryAckMessage | WorkspaceDeviceTaskDispatchMessage | WorkspaceDeviceTaskRenewedMessage | WorkspaceDeviceTaskCompleteAckMessage | WorkspaceDeviceProtocolErrorMessage | WorkspaceAgentTurnOfferMessage | WorkspaceAgentTurnAssignMessage | WorkspaceAgentTurnCancelMessage | WorkspaceAgentInteractionResolveMessage | WorkspaceAgentAttemptLeaseRenewedMessage | WorkspaceAgentAttemptEventAckMessage;
+export interface WorkspaceDeviceTaskReceipt {
+    taskId: string;
+    payloadHash: string;
+    leaseToken: string;
+    state: "running" | "completed";
+    result?: WorkspaceDeviceTaskResult;
+    updatedAt: string;
+}
+export interface WorkspaceSkillArtifact {
+    bundle: WorkspaceDeviceSkillArtifactBundle;
+}

package/dist/device-protocol.js

@@ -0,0 +1,326 @@
+export const WORKSPACE_DEVICE_PROTOCOL_VERSION = 5;
+export const WORKSPACE_DEVICE_WS_PATH = "/api/device-connection";
+export const WORKSPACE_INSTALLATION_PROOF_ALGORITHM = "Ed25519";
+export const WORKSPACE_INSTALLATION_PROOF_PLUGIN_ID = "workspace";
+export const WORKSPACE_INSTALLATION_PROOF_DOMAIN = "rynx-plugin-installation-proof-v1";
+export const WORKSPACE_DEVICE_PROOF_CONTEXT = "rynx-workspace-device-proof-v1";
+export const WORKSPACE_DEVICE_ACCESS_PROOF_CONTEXT = "rynx-workspace-device-access-proof-v1";
+export function workspaceInstallationProofChallenge(serverId, workspaceId, challenge) {
+    return `${WORKSPACE_DEVICE_PROOF_CONTEXT}\0${serverId}\0${workspaceId}\0${challenge}`;
+}
+export function workspaceInstallationProofMessage(installationId, serverId, workspaceId, challenge) {
+    return `${WORKSPACE_INSTALLATION_PROOF_DOMAIN}\0${installationId}\0plugin:${WORKSPACE_INSTALLATION_PROOF_PLUGIN_ID}\0${workspaceInstallationProofChallenge(serverId, workspaceId, challenge)}`;
+}
+export function workspaceDeviceAccessProofChallenge(serverId, authorizationId, nonce) {
+    return `${WORKSPACE_DEVICE_ACCESS_PROOF_CONTEXT}\0${serverId}\0${authorizationId}\0${nonce}`;
+}
+export function workspaceDeviceAccessProofMessage(installationId, serverId, authorizationId, nonce) {
+    return `${WORKSPACE_INSTALLATION_PROOF_DOMAIN}\0${installationId}\0plugin:${WORKSPACE_INSTALLATION_PROOF_PLUGIN_ID}\0${workspaceDeviceAccessProofChallenge(serverId, authorizationId, nonce)}`;
+}
+/** One source of truth for both the WebSocket boundary and durable Run store. */
+export const WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS = {
+    codeLength: 256,
+    textLength: 16_384,
+    artifactCount: 256,
+    artifactKeyLength: 256,
+    interactionFieldCount: 64,
+    interactionActionCount: 16,
+    interactionOptionCount: 128,
+    interactionContextItemBytes: 64 * 1024,
+    interactionRequestBytes: 256 * 1024,
+};
+/**
+ * Validate and project daemon event data onto the product-visible allowlist.
+ * Native runtime payloads, paths, fences and identifiers must never pass this
+ * boundary merely because they are valid JSON.
+ */
+export function normalizeWorkspaceAgentAttemptEventData(eventType, value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const input = value;
+    const keys = Object.keys(input);
+    const exact = (allowed) => keys.every((key) => allowed.includes(key));
+    const optionalText = (key, maximum) => input[key] === undefined || (typeof input[key] === "string" && input[key].length <= maximum);
+    const text = WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.textLength;
+    const code = WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.codeLength;
+    switch (eventType) {
+        case "environment.preparing":
+        case "environment.ready":
+        case "session.ready":
+        case "turn.started":
+            return keys.length === 0 ? {} : null;
+        case "environment.failed":
+            if (!exact(["retryable", "sessionReusable", "errorCode", "errorMessage"]) ||
+                (input.retryable !== undefined && typeof input.retryable !== "boolean") ||
+                typeof input.sessionReusable !== "boolean" ||
+                (input.retryable === true && input.sessionReusable !== true) ||
+                !optionalText("errorCode", code) ||
+                !optionalText("errorMessage", text))
+                return null;
+            return {
+                ...(input.retryable !== undefined ? { retryable: input.retryable } : {}),
+                sessionReusable: input.sessionReusable,
+                ...(input.errorCode !== undefined ? { errorCode: input.errorCode } : {}),
+                ...(input.errorMessage !== undefined ? { errorMessage: input.errorMessage } : {}),
+            };
+        case "turn.progress":
+            if (!exact(["phase", "percent"]) ||
+                input.phase !== "working" ||
+                (input.percent !== undefined && (typeof input.percent !== "number" ||
+                    !Number.isFinite(input.percent) ||
+                    input.percent < 0 ||
+                    input.percent > 100)))
+                return null;
+            return {
+                phase: "working",
+                ...(input.percent !== undefined ? { percent: input.percent } : {}),
+            };
+        case "interaction.requested": {
+            if (!exact(["interaction"]))
+                return null;
+            const interaction = normalizeWorkspaceAgentInteractionRequest(input.interaction);
+            return interaction ? { interaction } : null;
+        }
+        case "interaction.resolved":
+            if (!exact(["interactionId", "actionId"]) ||
+                !nonEmptyBoundedString(input.interactionId, code) ||
+                !nonEmptyBoundedString(input.actionId, code))
+                return null;
+            return { interactionId: input.interactionId, actionId: input.actionId };
+        case "interaction.cancelled":
+            if (!exact(["interactionId", "reason"]) ||
+                !nonEmptyBoundedString(input.interactionId, code) ||
+                !optionalBoundedString(input.reason, text))
+                return null;
+            return {
+                interactionId: input.interactionId,
+                ...(input.reason !== undefined ? { reason: input.reason } : {}),
+            };
+        case "turn.completed": {
+            const artifactKeys = input.artifactKeys;
+            if (!exact(["finalResponse", "artifactKeys"]) ||
+                !optionalText("finalResponse", text) ||
+                (artifactKeys !== undefined && (!Array.isArray(artifactKeys) ||
+                    artifactKeys.length > WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.artifactCount ||
+                    artifactKeys.some((key) => typeof key !== "string" ||
+                        !key ||
+                        key.length > WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.artifactKeyLength))))
+                return null;
+            return {
+                ...(input.finalResponse !== undefined ? { finalResponse: input.finalResponse } : {}),
+                ...(artifactKeys !== undefined ? { artifactKeys: [...artifactKeys] } : {}),
+            };
+        }
+        case "turn.failed":
+        case "turn.execution_unknown":
+            if (!exact(["errorCode", "errorMessage"]) ||
+                !optionalText("errorCode", code) ||
+                !optionalText("errorMessage", text))
+                return null;
+            return {
+                ...(input.errorCode !== undefined ? { errorCode: input.errorCode } : {}),
+                ...(input.errorMessage !== undefined ? { errorMessage: input.errorMessage } : {}),
+            };
+    }
+}
+function normalizeWorkspaceAgentInteractionRequest(value) {
+    if (!isRecord(value))
+        return null;
+    if (!exactRecordKeys(value, [
+        "interactionId",
+        "kind",
+        "title",
+        "description",
+        "fields",
+        "actions",
+        "context",
+        "createdAt",
+    ]))
+        return null;
+    const code = WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.codeLength;
+    const text = WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.textLength;
+    if (!nonEmptyBoundedString(value.interactionId, code) ||
+        (value.kind !== "question" && value.kind !== "permission" && value.kind !== "form") ||
+        !nonEmptyBoundedString(value.title, text) ||
+        !optionalBoundedString(value.description, text) ||
+        !Array.isArray(value.fields) ||
+        value.fields.length > WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.interactionFieldCount ||
+        !Array.isArray(value.actions) ||
+        value.actions.length < 1 ||
+        value.actions.length > WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.interactionActionCount ||
+        typeof value.createdAt !== "string" ||
+        !Number.isFinite(Date.parse(value.createdAt)))
+        return null;
+    const fields = [];
+    const fieldIds = new Set();
+    for (const candidate of value.fields) {
+        const field = normalizeWorkspaceAgentInteractionField(candidate);
+        if (!field || fieldIds.has(field.id))
+            return null;
+        fieldIds.add(field.id);
+        fields.push(field);
+    }
+    const actions = [];
+    const actionIds = new Set();
+    for (const candidate of value.actions) {
+        const action = normalizeWorkspaceAgentInteractionAction(candidate);
+        if (!action || actionIds.has(action.id))
+            return null;
+        actionIds.add(action.id);
+        actions.push(action);
+    }
+    let context;
+    if (value.context !== undefined) {
+        if (!isRecord(value.context) ||
+            !exactRecordKeys(value.context, ["summary", "toolName", "command", "cwd", "diff"]) ||
+            !optionalBoundedString(value.context.summary, text) ||
+            !optionalBoundedString(value.context.toolName, code) ||
+            !optionalUtf8BoundedString(value.context.command, WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.interactionContextItemBytes) ||
+            !optionalUtf8BoundedString(value.context.cwd, WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.interactionContextItemBytes) ||
+            !optionalUtf8BoundedString(value.context.diff, WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.interactionContextItemBytes))
+            return null;
+        context = {
+            ...(value.context.summary !== undefined ? { summary: value.context.summary } : {}),
+            ...(value.context.toolName !== undefined ? { toolName: value.context.toolName } : {}),
+            ...(value.context.command !== undefined ? { command: value.context.command } : {}),
+            ...(value.context.cwd !== undefined ? { cwd: value.context.cwd } : {}),
+            ...(value.context.diff !== undefined ? { diff: value.context.diff } : {}),
+        };
+    }
+    const request = {
+        interactionId: value.interactionId,
+        kind: value.kind,
+        title: value.title,
+        ...(value.description !== undefined ? { description: value.description } : {}),
+        fields,
+        actions,
+        ...(context ? { context } : {}),
+        createdAt: new Date(value.createdAt).toISOString(),
+    };
+    if (utf8ByteLength(JSON.stringify(request)) >
+        WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.interactionRequestBytes)
+        return null;
+    return request;
+}
+function normalizeWorkspaceAgentInteractionField(value) {
+    if (!isRecord(value))
+        return null;
+    const code = WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.codeLength;
+    const text = WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.textLength;
+    if (!nonEmptyBoundedString(value.id, code) ||
+        !nonEmptyBoundedString(value.label, text) ||
+        !optionalBoundedString(value.description, text) ||
+        (value.required !== undefined && typeof value.required !== "boolean"))
+        return null;
+    if (value.type === "text") {
+        if (!exactRecordKeys(value, [
+            "id",
+            "type",
+            "label",
+            "description",
+            "required",
+            "secret",
+            "multiline",
+            "placeholder",
+        ]) ||
+            (value.secret !== undefined && typeof value.secret !== "boolean") ||
+            (value.multiline !== undefined && typeof value.multiline !== "boolean") ||
+            !optionalBoundedString(value.placeholder, text))
+            return null;
+        return {
+            id: value.id,
+            type: "text",
+            label: value.label,
+            ...(value.description !== undefined ? { description: value.description } : {}),
+            ...(value.required !== undefined ? { required: value.required } : {}),
+            ...(value.secret !== undefined ? { secret: value.secret } : {}),
+            ...(value.multiline !== undefined ? { multiline: value.multiline } : {}),
+            ...(value.placeholder !== undefined ? { placeholder: value.placeholder } : {}),
+        };
+    }
+    if (value.type !== "select" || !exactRecordKeys(value, [
+        "id",
+        "type",
+        "label",
+        "description",
+        "required",
+        "multiple",
+        "allowOther",
+        "options",
+    ]))
+        return null;
+    if ((value.multiple !== undefined && typeof value.multiple !== "boolean") ||
+        (value.allowOther !== undefined && typeof value.allowOther !== "boolean") ||
+        !Array.isArray(value.options) ||
+        value.options.length < 1 ||
+        value.options.length > WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.interactionOptionCount)
+        return null;
+    const optionValues = new Set();
+    const options = value.options.map((candidate) => {
+        if (!isRecord(candidate) ||
+            !exactRecordKeys(candidate, ["value", "label", "description"]) ||
+            !nonEmptyBoundedString(candidate.value, code) ||
+            !nonEmptyBoundedString(candidate.label, text) ||
+            !optionalBoundedString(candidate.description, text) ||
+            optionValues.has(candidate.value))
+            return null;
+        optionValues.add(candidate.value);
+        return {
+            value: candidate.value,
+            label: candidate.label,
+            ...(candidate.description !== undefined
+                ? { description: candidate.description }
+                : {}),
+        };
+    });
+    if (options.some((option) => option === null))
+        return null;
+    return {
+        id: value.id,
+        type: "select",
+        label: value.label,
+        ...(value.description !== undefined ? { description: value.description } : {}),
+        ...(value.required !== undefined ? { required: value.required } : {}),
+        ...(value.multiple !== undefined ? { multiple: value.multiple } : {}),
+        ...(value.allowOther !== undefined ? { allowOther: value.allowOther } : {}),
+        options: options,
+    };
+}
+function normalizeWorkspaceAgentInteractionAction(value) {
+    if (!isRecord(value) ||
+        !exactRecordKeys(value, ["id", "label", "description", "style", "requiresAnswers"]) ||
+        !nonEmptyBoundedString(value.id, WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.codeLength) ||
+        !nonEmptyBoundedString(value.label, WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.textLength) ||
+        !optionalBoundedString(value.description, WORKSPACE_AGENT_ATTEMPT_EVENT_LIMITS.textLength) ||
+        typeof value.requiresAnswers !== "boolean" ||
+        (value.style !== undefined &&
+            value.style !== "primary" && value.style !== "secondary" && value.style !== "danger"))
+        return null;
+    return {
+        id: value.id,
+        label: value.label,
+        ...(value.description !== undefined ? { description: value.description } : {}),
+        ...(value.style !== undefined
+            ? { style: value.style }
+            : {}),
+        requiresAnswers: value.requiresAnswers,
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function exactRecordKeys(value, allowed) {
+    return Object.keys(value).every((key) => allowed.includes(key));
+}
+function nonEmptyBoundedString(value, maximum) {
+    return typeof value === "string" && Boolean(value.trim()) && value.length <= maximum;
+}
+function optionalBoundedString(value, maximum) {
+    return value === undefined || (typeof value === "string" && value.length <= maximum);
+}
+function optionalUtf8BoundedString(value, maximum) {
+    return value === undefined || (typeof value === "string" && utf8ByteLength(value) <= maximum);
+}
+function utf8ByteLength(value) {
+    return new TextEncoder().encode(value).byteLength;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./agent-options.js";
+export * from "./agent-execution.js";
+export * from "./agent-scheduler.js";
+export * from "./skill-path.js";
+export * from "./device-protocol.js";
+export * from "./skill-name.js";
+export * from "./types.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./agent-options.js";
+export * from "./agent-execution.js";
+export * from "./agent-scheduler.js";
+export * from "./skill-path.js";
+export * from "./device-protocol.js";
+export * from "./skill-name.js";
+export * from "./types.js";

package/dist/skill-name.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Return the portable skill identity used by workspace, daemon, and runtimes.
+ * Runtime skill loaders expect a lowercase kebab-case directory/frontmatter
+ * name, so display names must never be used as the installation identity.
+ */
+export declare function canonicalWorkspaceSkillName(value: string, fallback?: string): string;