@timurproko/a1 0.1.0 → 0.1.1-dev.2

package/dist/src/features/launch/profile-paths.d.ts

@@ -1,8 +1,8 @@
 import type { LaunchProfileId } from "./profiles.js";
 export interface LaunchProfilePaths {
     readonly home: string;
-    readonly addoneRoot: string;
-    readonly addoneAgent: string;
+    readonly managedStateRoot: string;
+    readonly agentProfile: string;
     readonly sandbox: string;
 }
 export interface LaunchProfilePathOptions {
@@ -13,4 +13,3 @@ export interface LaunchProfilePathOptions {
 }
 export declare function resolveLaunchProfilePaths(options?: LaunchProfilePathOptions): LaunchProfilePaths;
 export declare function configurationRootForProfile(profileId: LaunchProfileId, paths: LaunchProfilePaths): string | null;
-//# sourceMappingURL=profile-paths.d.ts.map

package/dist/src/features/launch/profile-paths.js

@@ -1,21 +1,23 @@
 import { homedir } from "node:os";
 import { posix, win32 } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
 export function resolveLaunchProfilePaths(options = {}) {
     const environment = options.environment ?? process.env;
     const path = options.platform === "win32" || (options.platform === undefined && process.platform === "win32") ? win32 : posix;
-    const selectedHome = options.home ?? environment.ADDONE_PROFILE_HOME ?? options.readHome?.() ?? homedir();
+    const selectedHome = options.home ?? environment[PRODUCT_IDENTITY.environment.profileHome] ?? options.readHome?.() ?? homedir();
     const home = validateAbsolutePath(selectedHome, "effective user home", path);
-    const addoneRoot = path.resolve(home, ".a1");
+    const agentProfile = path.resolve(home, PRODUCT_IDENTITY.state.piAgentProfile);
+    const managedStateRoot = path.dirname(agentProfile);
     return Object.freeze({
         home,
-        addoneRoot,
-        addoneAgent: path.resolve(addoneRoot, "agent"),
-        sandbox: path.resolve(addoneRoot, "sandbox"),
+        managedStateRoot,
+        agentProfile,
+        sandbox: path.resolve(home, PRODUCT_IDENTITY.state.piSandboxProfile),
     });
 }
 export function configurationRootForProfile(profileId, paths) {
-    if (profileId === "addone")
-        return paths.addoneAgent;
+    if (profileId === "a1")
+        return paths.agentProfile;
     if (profileId === "sandbox")
         return paths.sandbox;
     return null;
@@ -27,4 +29,3 @@ function validateAbsolutePath(value, name, path) {
         throw new TypeError(`${name} must be absolute`);
     return path.resolve(value);
 }
-//# sourceMappingURL=profile-paths.js.map

package/dist/src/features/launch/profiles.d.ts

@@ -1,13 +1,12 @@
 import type { LaunchProfileId } from "../../foundation/lifecycle/index.js";
 export type { LaunchProfileId } from "../../foundation/lifecycle/index.js";
-export type PiConfigurationRootPolicy = "addone-agent" | "pi-default" | "addone-sandbox";
+export type ConfigurationRootPolicy = "agent-profile" | "pi-default" | "sandbox-profile";
 export type ProjectTrustPolicy = "pi-default" | "ignore";
 export interface LaunchProfileContract {
     readonly id: LaunchProfileId;
     readonly productSurface: "agent" | "vanilla-baseline" | "isolated-profile";
-    readonly piConfigurationRoot: PiConfigurationRootPolicy;
+    readonly configurationRootPolicy: ConfigurationRootPolicy;
     readonly projectTrust: ProjectTrustPolicy;
     readonly terminalCapability: "owned-ui" | "transparent";
 }
 export declare function launchProfileContract(id: LaunchProfileId): LaunchProfileContract;
-//# sourceMappingURL=profiles.d.ts.map

package/dist/src/features/launch/profiles.js

@@ -1,22 +1,22 @@
 const contracts = Object.freeze({
-    addone: Object.freeze({
-        id: "addone",
+    "a1": Object.freeze({
+        id: "a1",
         productSurface: "agent",
-        piConfigurationRoot: "addone-agent",
+        configurationRootPolicy: "agent-profile",
         projectTrust: "pi-default",
         terminalCapability: "owned-ui",
     }),
     pi: Object.freeze({
         id: "pi",
         productSurface: "vanilla-baseline",
-        piConfigurationRoot: "pi-default",
+        configurationRootPolicy: "pi-default",
         projectTrust: "pi-default",
         terminalCapability: "transparent",
     }),
     sandbox: Object.freeze({
         id: "sandbox",
         productSurface: "isolated-profile",
-        piConfigurationRoot: "addone-sandbox",
+        configurationRootPolicy: "sandbox-profile",
         projectTrust: "ignore",
         terminalCapability: "transparent",
     }),
@@ -24,4 +24,3 @@ const contracts = Object.freeze({
 export function launchProfileContract(id) {
     return contracts[id];
 }
-//# sourceMappingURL=profiles.js.map

package/dist/src/features/launch/runtime-selection.d.ts

@@ -1,5 +1,5 @@
 import { type LaunchProfileId } from "../../foundation/lifecycle/index.js";
-export type TransparentInteractiveProfileId = Exclude<LaunchProfileId, "addone">;
+export type TransparentInteractiveProfileId = Exclude<LaunchProfileId, "a1">;
 export type InteractiveRuntimeSelection = {
     readonly kind: "owned-ui";
 } | {
@@ -12,4 +12,3 @@ export interface InteractiveRuntimeRunners {
 }
 export declare function selectInteractiveRuntime(profileId: string): InteractiveRuntimeSelection;
 export declare function runSelectedInteractiveRuntime(profileId: string, runners: InteractiveRuntimeRunners): Promise<number>;
-//# sourceMappingURL=runtime-selection.d.ts.map

package/dist/src/features/launch/runtime-selection.js

@@ -1,7 +1,7 @@
 import { assertLaunchProfileId } from "../../foundation/lifecycle/index.js";
 export function selectInteractiveRuntime(profileId) {
     assertLaunchProfileId(profileId);
-    return profileId === "addone"
+    return profileId === "a1"
         ? Object.freeze({ kind: "owned-ui" })
         : Object.freeze({ kind: "transparent", profileId });
 }
@@ -11,4 +11,3 @@ export async function runSelectedInteractiveRuntime(profileId, runners) {
         ? await runners.ownedUi()
         : await runners.transparent(selection.profileId);
 }
-//# sourceMappingURL=runtime-selection.js.map

package/dist/src/features/owned-ui/customization.d.ts

@@ -1,4 +1,4 @@
-import { type OwnedUiCommand, type OwnedUiCustomization, type OwnedUiSlotId } from "../../foundation/owned-ui-contracts/index.js";
+import { type OwnedUiCommand, type OwnedUiCustomization, type OwnedUiSlotId, type OwnedUiTranscriptBlock } from "../../foundation/owned-ui-contracts/index.js";
 export interface OwnedUiSlotImplementation {
     readonly payload: unknown;
     render?(input: unknown, width: number): readonly string[];
@@ -32,5 +32,7 @@ export declare class OwnedUiCustomizationRegistry {
     clear(): void;
     installCommands(surface: OwnedCommandSurface, sessionId: string): readonly string[];
 }
-export declare function createVanillaUiCustomizationRegistry(): OwnedUiCustomizationRegistry;
-//# sourceMappingURL=customization.d.ts.map
+export interface VanillaUiCustomizationPorts {
+    readonly renderTranscriptBlock: (block: OwnedUiTranscriptBlock, width: number) => readonly string[];
+}
+export declare function createVanillaUiCustomizationRegistry(ports: VanillaUiCustomizationPorts): OwnedUiCustomizationRegistry;

package/dist/src/features/owned-ui/customization.js

@@ -1,5 +1,4 @@
 import { assertOwnedUiCustomization, } from "../../foundation/owned-ui-contracts/index.js";
-import { renderPiShellTranscriptBlock } from "../../foundation/pi-component-adapter/index.js";
 export class OwnedCommandSurface {
     #handlers = new Map();
     #sequence = 0;
@@ -81,7 +80,7 @@ export class OwnedUiCustomizationRegistry {
         return registrations;
     }
 }
-export function createVanillaUiCustomizationRegistry() {
+export function createVanillaUiCustomizationRegistry(ports) {
     const registry = new OwnedUiCustomizationRegistry();
     const register = (slot, id, label, implementation = { payload: {} }) => registry.register({
         id,
@@ -96,7 +95,7 @@ export function createVanillaUiCustomizationRegistry() {
     });
     register("transcript-block", "vanilla-transcript", "Vanilla transcript", {
         payload: {},
-        render: (input, width) => renderPiShellTranscriptBlock(input, width, process.cwd()),
+        render: (input, width) => ports.renderTranscriptBlock(input, width),
     });
     register("tool-card", "vanilla-tool-card", "Vanilla tool cards");
     register("editor", "vanilla-editor", "Vanilla editor");
@@ -107,4 +106,3 @@ export function createVanillaUiCustomizationRegistry() {
     register("layout", "vanilla-fullscreen", "Fullscreen session");
     return registry;
 }
-//# sourceMappingURL=customization.js.map

package/dist/src/features/owned-ui/diagnostics.d.ts

@@ -31,4 +31,3 @@ export declare class OwnedUiDiagnosticsRecorder {
     snapshot(): OwnedUiDiagnosticsSnapshot;
 }
 export declare function redactDiagnosticMessage(message: string): string;
-//# sourceMappingURL=diagnostics.d.ts.map

package/dist/src/features/owned-ui/diagnostics.js

@@ -92,4 +92,3 @@ function sanitizeDiagnosticCode(code) {
         throw new TypeError("diagnostic code is invalid");
     return normalized.slice(0, 128);
 }
-//# sourceMappingURL=diagnostics.js.map

package/dist/src/features/owned-ui/index.d.ts

@@ -1,5 +1,3 @@
 export * from "./customization.js";
 export * from "./diagnostics.js";
 export * from "./run.js";
-export * from "./pi-session-shell.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/features/owned-ui/index.js

@@ -1,5 +1,3 @@
 export * from "./customization.js";
 export * from "./diagnostics.js";
 export * from "./run.js";
-export * from "./pi-session-shell.js";
-//# sourceMappingURL=index.js.map

package/dist/src/features/owned-ui/run.d.ts

@@ -1,9 +1,5 @@
-import { type PiEngineAdapter } from "../../foundation/pi-engine-adapter/index.js";
-import type { PiTuiTerminalPort } from "../../foundation/pi-tui-runtime-adapter/index.js";
+import type { OwnedUiApplicationPort } from "../../foundation/presentation-contracts/index.js";
 export interface OwnedUiRunOptions {
-    readonly cwd?: string;
-    readonly terminal?: PiTuiTerminalPort;
-    readonly adapter?: PiEngineAdapter;
+    readonly application: OwnedUiApplicationPort;
 }
-export declare function runOwnedUi(options?: OwnedUiRunOptions): Promise<number>;
-//# sourceMappingURL=run.d.ts.map
+export declare function runOwnedUi(options: OwnedUiRunOptions): Promise<number>;

package/dist/src/features/owned-ui/run.js

@@ -1,21 +1,13 @@
-import { createPiEngineAdapter } from "../../foundation/pi-engine-adapter/index.js";
-import { PiSessionShell } from "./pi-session-shell.js";
-export async function runOwnedUi(options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const adapter = options.adapter ?? await createPiEngineAdapter({ cwd });
-    const shellOptions = options.terminal === undefined
-        ? { adapter, cwd }
-        : { adapter, cwd, terminal: options.terminal };
-    const shell = new PiSessionShell(shellOptions);
+export async function runOwnedUi(options) {
+    const { application } = options;
     try {
-        shell.start();
-        await adapter.flushEvents();
-        if (!adapter.disposed)
-            await shell.waitUntilStopped();
+        application.start();
+        await application.flush();
+        if (!application.disposed)
+            await application.waitUntilStopped();
         return 0;
     }
     finally {
-        await shell.dispose();
+        await application.dispose();
     }
 }
-//# sourceMappingURL=run.js.map

package/dist/src/features/workspace/capabilities.d.ts

@@ -29,4 +29,3 @@ export type WorkspaceActionGateResult = {
 };
 export declare function gateWorkspaceAction(agent: ManagedAgentDescriptor, action: WorkspaceCapabilityAction): WorkspaceActionGateResult;
 export declare function availableWorkspaceActions(agent: ManagedAgentDescriptor): readonly WorkspaceCapabilityActionType[];
-//# sourceMappingURL=capabilities.d.ts.map

package/dist/src/features/workspace/capabilities.js

@@ -73,4 +73,3 @@ function allow(action) {
 function reject(code, diagnostic) {
     return { kind: "rejected", code, diagnostic };
 }
-//# sourceMappingURL=capabilities.js.map

package/dist/src/features/workspace/index.d.ts

@@ -4,4 +4,3 @@ export * from "./reconciliation.js";
 export * from "./reducer.js";
 export * from "./router.js";
 export * from "./store.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/features/workspace/index.js

@@ -4,4 +4,3 @@ export * from "./reconciliation.js";
 export * from "./reducer.js";
 export * from "./router.js";
 export * from "./store.js";
-//# sourceMappingURL=index.js.map

package/dist/src/features/workspace/presentation.d.ts

@@ -19,7 +19,7 @@ export interface WorkspaceAgentPresentationRow {
 }
 export interface WorkspacePresentationModel {
     readonly role: "listbox";
-    readonly label: "AddOne agents";
+    readonly label: string;
     readonly selectedAgentId: string | null;
     readonly rows: readonly WorkspaceAgentPresentationRow[];
     readonly overflowCount: number;
@@ -28,4 +28,3 @@ export interface WorkspacePresentationModel {
 }
 export declare function presentWorkspace(view: WorkspaceView, options?: WorkspacePresentationOptions): WorkspacePresentationModel;
 export declare function workspaceSelectionForKey(view: WorkspaceView, key: "ArrowDown" | "ArrowUp" | "Home" | "End"): string | null;
-//# sourceMappingURL=presentation.d.ts.map

package/dist/src/features/workspace/presentation.js

@@ -1,15 +1,17 @@
 import { availableWorkspaceActions } from "./capabilities.js";
+import { PRODUCT_TEXT } from "../../product-identity.js";
+const WORKSPACE_LABEL = `${PRODUCT_TEXT.displayName} agents`;
 export function presentWorkspace(view, options = {}) {
     const maxRows = boundedInteger(options.maxRows ?? 8, 1, 100, "maximum workspace rows");
     const maxLabelWidth = boundedInteger(options.maxLabelWidth ?? 32, 8, 64, "maximum workspace label width");
     const rows = view.agents.slice(0, maxRows).map(agent => presentAgent(agent, view.selectedAgentId === agent.id, maxLabelWidth));
     const overflowCount = Math.max(0, view.agents.length - rows.length);
     const text = rows.length === 0
-        ? "AddOne agents\nNo managed agents."
-        : ["AddOne agents", ...rows.map(row => row.text), ...(overflowCount > 0 ? [`… ${overflowCount} more`] : [])].join("\n");
+        ? `${WORKSPACE_LABEL}\nNo managed agents.`
+        : [WORKSPACE_LABEL, ...rows.map(row => row.text), ...(overflowCount > 0 ? [`… ${overflowCount} more`] : [])].join("\n");
     return Object.freeze({
         role: "listbox",
-        label: "AddOne agents",
+        label: WORKSPACE_LABEL,
         selectedAgentId: view.selectedAgentId,
         rows: Object.freeze(rows),
         overflowCount,
@@ -66,4 +68,3 @@ function boundedInteger(value, minimum, maximum, name) {
     }
     return value;
 }
-//# sourceMappingURL=presentation.js.map

package/dist/src/features/workspace/reconciliation.d.ts

@@ -13,4 +13,3 @@ export interface WorkspaceReconciliationReport {
     readonly entries: readonly WorkspaceReconciliationEntry[];
 }
 export declare function reconcileWorkspaceRestart(reducer: WorkspaceReducer, store: WorkspaceStore, proofs: ReadonlyMap<string, StructuredResumeProof>, reconciledAt?: string): WorkspaceReconciliationReport;
-//# sourceMappingURL=reconciliation.d.ts.map

package/dist/src/features/workspace/reconciliation.js

@@ -80,4 +80,3 @@ function persistRecoveryOutcome(store, authority, previousStatus, status, reconc
 function entry(agentId, outcome, code, diagnostic) {
     return Object.freeze({ agentId, outcome, code, diagnostic });
 }
-//# sourceMappingURL=reconciliation.js.map

package/dist/src/features/workspace/reducer.d.ts

@@ -40,4 +40,3 @@ export declare class WorkspaceReducer {
     markFailed(agentId: string, code: string, message: string): WorkspaceReducerResult<WorkspaceAgentState>;
     view(): WorkspaceView;
 }
-//# sourceMappingURL=reducer.d.ts.map

package/dist/src/features/workspace/reducer.js

@@ -211,4 +211,3 @@ function assertDisplayName(value) {
         throw new TypeError("workspace display name is invalid");
     }
 }
-//# sourceMappingURL=reducer.js.map

package/dist/src/features/workspace/router.d.ts

@@ -29,4 +29,3 @@ export declare class WorkspaceRouter {
     cancelStructuredCommand(agentId: string, targetCorrelationId: string): Promise<WorkspaceRouterResult<StructuredCommandRecord>>;
     view(): WorkspaceView;
 }
-//# sourceMappingURL=router.d.ts.map

package/dist/src/features/workspace/router.js

@@ -122,4 +122,3 @@ function applied(view, value) {
 function reject(code, diagnostic) {
     return { kind: "rejected", code, diagnostic };
 }
-//# sourceMappingURL=router.js.map

package/dist/src/features/workspace/store.d.ts

@@ -15,4 +15,3 @@ export declare class WorkspaceStore {
     persistRecoveryReference(authority: AgentRecoveryAuthority, status: "pending" | "accepted" | "rejected" | "discontinuous", rollbackMetadata: Readonly<Record<string, unknown>>, updatedAt?: string): void;
     close(): void;
 }
-//# sourceMappingURL=store.d.ts.map

package/dist/src/features/workspace/store.js

@@ -52,4 +52,3 @@ function toWorkspaceAgent(record) {
         failure: record.presentation.failure,
     };
 }
-//# sourceMappingURL=store.js.map

package/dist/src/foundation/agent-engine-contracts/capability-ports.d.ts

@@ -0,0 +1,95 @@
+import type { AgentJsonValue, AgentModelDescriptor, AgentResourceDescriptor, AgentSettingDescriptor } from "./domain.js";
+export interface AgentModelPort {
+    readonly capabilities: {
+        readonly selection: boolean;
+        readonly refresh: boolean;
+        readonly scopedCatalog: boolean;
+    };
+    listModels(scope?: string): Promise<readonly AgentModelDescriptor[]>;
+    currentModel(): Promise<AgentModelDescriptor | null>;
+    selectModel?(providerId: string, modelId: string): Promise<void>;
+    refreshModels?(): Promise<void>;
+}
+export interface AgentAuthenticationPort {
+    readonly capabilities: {
+        readonly login: boolean;
+        readonly logout: boolean;
+    };
+    status(providerId: string): Promise<"authenticated" | "unauthenticated" | "unavailable">;
+    login?(providerId: string, signal?: AbortSignal): Promise<void>;
+    logout?(providerId: string): Promise<void>;
+}
+export interface AgentSettingsPort {
+    readonly capabilities: {
+        readonly write: boolean;
+        readonly flush: boolean;
+    };
+    listSettings(): Promise<readonly AgentSettingDescriptor[]>;
+    readSetting(key: string): Promise<AgentJsonValue | undefined>;
+    writeSetting?(key: string, value: AgentJsonValue): Promise<void>;
+    flush?(): Promise<void>;
+}
+export interface AgentResourcesPort {
+    readonly capabilities: {
+        readonly reload: boolean;
+        readonly extensionBinding: boolean;
+    };
+    discoverResources(): Promise<readonly AgentResourceDescriptor[]>;
+    reload?(): Promise<void>;
+    bindExtensions?(sessionId: string): Promise<AgentExtensionBinding>;
+}
+export interface AgentExtensionBinding {
+    readonly sessionId: string;
+    dispose(): Promise<void>;
+}
+export interface AgentExtensionCommand {
+    readonly name: string;
+    readonly description: string;
+}
+export interface AgentSessionMetadata {
+    readonly sessionId: string;
+    readonly sessionName: string | null;
+    readonly sessionPath: string | null;
+    readonly cwd: string;
+}
+export interface AgentExtensionFailure {
+    readonly extensionPath: string | null;
+    readonly operation: string;
+    readonly message: string;
+    readonly recoverable: boolean;
+}
+export interface AgentExtensionPort {
+    readonly capabilities: {
+        readonly reload: boolean;
+        readonly binding: boolean;
+        readonly renderers: boolean;
+    };
+    discoverCommands(): Promise<readonly AgentExtensionCommand[]>;
+    sessionMetadata(): Promise<AgentSessionMetadata>;
+    bind?(sessionId: string): Promise<AgentExtensionBinding>;
+    reload?(): Promise<void>;
+    resolveMessageRenderer?(customType: string): unknown;
+    resolveToolRenderer?(toolName: string): unknown;
+    subscribeFailures(listener: (failure: AgentExtensionFailure) => void): () => void;
+}
+export interface AgentWorkflowDescriptor {
+    readonly id: string;
+    readonly label: string;
+    readonly requiredCommands: readonly string[];
+}
+export interface AgentWorkflowPort {
+    readonly capabilities: {
+        readonly execute: boolean;
+    };
+    listWorkflows(): Promise<readonly AgentWorkflowDescriptor[]>;
+    executeWorkflow?(workflowId: string, input: AgentJsonValue, signal?: AbortSignal): Promise<AgentJsonValue>;
+}
+export interface AgentServicePorts {
+    readonly models: AgentModelPort;
+    readonly authentication: AgentAuthenticationPort;
+    readonly settings: AgentSettingsPort;
+    readonly resources: AgentResourcesPort;
+    readonly extensions: AgentExtensionPort;
+    readonly workflows: AgentWorkflowPort;
+}
+export declare function assertAgentServicePorts(ports: AgentServicePorts): void;

package/dist/src/foundation/agent-engine-contracts/capability-ports.js

@@ -0,0 +1,35 @@
+export function assertAgentServicePorts(ports) {
+    required(ports.models, ["listModels", "currentModel"], "model");
+    advertised(ports.models, "selection", "selectModel", "model");
+    advertised(ports.models, "refresh", "refreshModels", "model");
+    required(ports.authentication, ["status"], "authentication");
+    advertised(ports.authentication, "login", "login", "authentication");
+    advertised(ports.authentication, "logout", "logout", "authentication");
+    required(ports.settings, ["listSettings", "readSetting"], "settings");
+    advertised(ports.settings, "write", "writeSetting", "settings");
+    advertised(ports.settings, "flush", "flush", "settings");
+    required(ports.resources, ["discoverResources"], "resources");
+    advertised(ports.resources, "reload", "reload", "resources");
+    advertised(ports.resources, "extensionBinding", "bindExtensions", "resources");
+    required(ports.extensions, ["discoverCommands", "sessionMetadata", "subscribeFailures"], "extensions");
+    advertised(ports.extensions, "reload", "reload", "extensions");
+    advertised(ports.extensions, "binding", "bind", "extensions");
+    advertised(ports.extensions, "renderers", "resolveMessageRenderer", "extensions");
+    advertised(ports.extensions, "renderers", "resolveToolRenderer", "extensions");
+    required(ports.workflows, ["listWorkflows"], "workflow");
+    advertised(ports.workflows, "execute", "executeWorkflow", "workflow");
+}
+function required(port, operations, label) {
+    if (!port || typeof port.capabilities !== "object")
+        throw new TypeError(`${label} port and capabilities are required`);
+    for (const operation of operations)
+        if (typeof port[operation] !== "function")
+            throw new TypeError(`${label} port requires ${operation}`);
+}
+function advertised(port, capability, operation, label) {
+    const enabled = port.capabilities[capability];
+    if (typeof enabled !== "boolean")
+        throw new TypeError(`${label} capability ${capability} must be explicit`);
+    if (enabled && typeof port[operation] !== "function")
+        throw new TypeError(`${label} capability ${capability} requires ${operation}`);
+}

package/dist/src/foundation/agent-engine-contracts/domain-validation.d.ts

@@ -0,0 +1,12 @@
+import type { AgentDomainCapabilities, AgentFailure, AgentMessage, AgentMessageContent, AgentModelDescriptor, AgentResourceDescriptor, AgentSettingDescriptor, AgentThemeDescriptor, AgentToolDescriptor, AgentUiContribution, AgentUsage } from "./domain.js";
+export declare function assertAgentDomainCapabilities(value: AgentDomainCapabilities): void;
+export declare function assertAgentMessage(message: AgentMessage): void;
+export declare function assertAgentMessageContent(content: AgentMessageContent): void;
+export declare function assertAgentToolDescriptor(value: AgentToolDescriptor): void;
+export declare function assertAgentUsage(value: AgentUsage): void;
+export declare function assertAgentModelDescriptor(value: AgentModelDescriptor): void;
+export declare function assertAgentSettingDescriptor(value: AgentSettingDescriptor): void;
+export declare function assertAgentResourceDescriptor(value: AgentResourceDescriptor): void;
+export declare function assertAgentThemeDescriptor(value: AgentThemeDescriptor): void;
+export declare function assertAgentUiContribution(value: AgentUiContribution): void;
+export declare function assertAgentFailure(value: AgentFailure): void;

package/dist/src/foundation/agent-engine-contracts/domain-validation.js

@@ -0,0 +1,89 @@
+const CONTENT = new Set(["text", "thinking", "image", "tool-call", "tool-result", "unknown"]);
+const CAPABILITIES = {
+    tools: new Set(["discovery", "invocation", "streaming-results"]),
+    usage: new Set(["tokens", "cache", "cost"]),
+    models: new Set(["discovery", "selection", "thinking-level"]),
+    settings: new Set(["read", "write"]),
+    resources: new Set(["commands", "prompts", "skills", "extensions", "themes"]),
+    uiContributions: new Set(["transcript", "tool", "editor", "status", "dialog", "overlay", "unknown"]),
+};
+const FAILURES = new Set(["configuration", "authentication", "authorization", "network", "rate-limit", "context-limit", "tool", "cancelled", "engine", "unknown"]);
+export function assertAgentDomainCapabilities(value) {
+    unique(value.messageContent, CONTENT, "message content capability");
+    for (const [key, allowed] of Object.entries(CAPABILITIES))
+        unique(value[key], allowed, `${key} capability`);
+}
+export function assertAgentMessage(message) {
+    id(message.id, "message id");
+    if (!["user", "assistant", "tool", "system"].includes(message.role) || !["streaming", "final"].includes(message.status))
+        throw new TypeError("message metadata is invalid");
+    if (!Array.isArray(message.content) || message.content.length === 0)
+        throw new TypeError("message content is empty");
+    for (const content of message.content)
+        assertAgentMessageContent(content);
+}
+export function assertAgentMessageContent(content) {
+    if (!CONTENT.has(content.kind))
+        throw new TypeError("message content kind is unknown and must use the unknown envelope");
+    if (content.kind === "text" || content.kind === "thinking")
+        text(content.text, "message text", true);
+    if (content.kind === "image") {
+        text(content.mediaType, "image media type");
+        text(content.data, "image data");
+    }
+    if (content.kind === "tool-call") {
+        id(content.invocationId, "tool invocation id");
+        id(content.toolName, "tool name");
+        json(content.input, "tool input");
+    }
+    if (content.kind === "tool-result") {
+        id(content.invocationId, "tool result invocation id");
+        json(content.output, "tool output");
+        if (typeof content.failed !== "boolean")
+            throw new TypeError("tool result failure flag is invalid");
+    }
+    if (content.kind === "unknown") {
+        text(content.sourceType, "unknown content source type");
+        json(content.payload, "unknown content payload");
+    }
+}
+export function assertAgentToolDescriptor(value) { id(value.name, "tool name"); text(value.description, "tool description", true); json(value.inputSchema, "tool input schema"); }
+export function assertAgentUsage(value) { for (const amount of [value.inputTokens, value.outputTokens, value.cacheReadTokens, value.cacheWriteTokens])
+    nonNegative(amount, "usage token count"); if (value.cost !== null && (!(typeof value.cost === "number") || !Number.isFinite(value.cost) || value.cost < 0))
+    throw new TypeError("usage cost is invalid"); }
+export function assertAgentModelDescriptor(value) { id(value.providerId, "model provider id"); id(value.modelId, "model id"); text(value.displayName, "model display name"); nonNegative(value.contextWindow, "model context window"); unique(value.thinkingLevels, undefined, "model thinking levels"); }
+export function assertAgentSettingDescriptor(value) { id(value.key, "setting key"); if (!["boolean", "number", "string", "enum", "json"].includes(value.valueType) || typeof value.writable !== "boolean")
+    throw new TypeError("setting descriptor is invalid"); if (value.choices)
+    for (const choice of value.choices)
+        json(choice, "setting choice"); }
+export function assertAgentResourceDescriptor(value) { id(value.id, "resource id"); if (!["command", "prompt", "skill", "extension", "other"].includes(value.kind))
+    throw new TypeError("resource kind is invalid"); text(value.label, "resource label"); json(value.metadata, "resource metadata"); }
+export function assertAgentThemeDescriptor(value) { id(value.id, "theme id"); text(value.label, "theme label"); if (!value.tokens || typeof value.tokens !== "object" || Object.values(value.tokens).some(token => typeof token !== "string"))
+    throw new TypeError("theme tokens are invalid"); }
+export function assertAgentUiContribution(value) { id(value.id, "UI contribution id"); if (!CAPABILITIES.uiContributions.has(value.slot) || !Number.isSafeInteger(value.version) || value.version < 1)
+    throw new TypeError("UI contribution metadata is invalid"); json(value.payload, "UI contribution payload"); }
+export function assertAgentFailure(value) { if (!FAILURES.has(value.category))
+    throw new TypeError("failure category is invalid"); id(value.code, "failure code"); text(value.message, "failure message"); if (typeof value.retryable !== "boolean")
+    throw new TypeError("failure retryability is invalid"); json(value.details, "failure details"); }
+function unique(values, allowed, label) { if (!Array.isArray(values))
+    throw new TypeError(`${label} must be an array`); const found = new Set(); for (const value of values) {
+    if ((allowed && !allowed.has(value)) || typeof value !== "string")
+        throw new TypeError(`${label} is invalid: ${String(value)}`);
+    if (found.has(value))
+        throw new TypeError(`${label} is duplicated: ${String(value)}`);
+    found.add(value);
+} }
+function id(value, label) { if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(value))
+    throw new TypeError(`${label} is invalid`); }
+function text(value, label, empty = false) { if (typeof value !== "string" || (!empty && value.length === 0) || Buffer.byteLength(value) > 256 * 1024)
+    throw new TypeError(`${label} is invalid`); }
+function nonNegative(value, label) { if (!Number.isSafeInteger(value) || value < 0)
+    throw new TypeError(`${label} is invalid`); }
+function json(value, label) { try {
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined || Buffer.byteLength(encoded) > 256 * 1024)
+        throw new Error();
+}
+catch {
+    throw new TypeError(`${label} must be bounded JSON`);
+} }