@pasko70/pibo 1.16.6 → 2.0.0

package/dist/agent-runtime/auth.js

@@ -0,0 +1,28 @@
+export const AGENT_RUNTIME_AUTH_METHOD_IDS = ["device_code", "browser_oauth", "api_key"];
+export const AGENT_RUNTIME_AUTH_COMPLETION_MODES = ["immediate", "explicit", "notification"];
+export function redactAgentRuntimeAuthText(value, maxLength = 1_000) {
+    return value
+        .replace(/Bearer\s+\S+/gi, "Bearer [redacted]")
+        .replace(/\b(?:sk|pk|ghp|github_pat|pibo)[-_][A-Za-z0-9_-]{8,}\b/g, "[redacted]")
+        .replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, "[redacted]")
+        .replace(/\b(access[_-]?token|refresh[_-]?token|id[_-]?token|api[_-]?key|token|secret|password|account[_-]?id)\b(\s*["']?\s*[:=]\s*["']?)([^\s"'&,}]+)/gi, "$1$2[redacted]")
+        .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, "[redacted account]")
+        .replace(/`(?:\/|[A-Za-z]:[\\/])[^`\r\n]+`/g, "`[redacted path]`")
+        .replace(/\bfile:\/\/\/?[^\s"'`,)]+/gi, "file://[redacted path]")
+        .slice(0, maxLength);
+}
+export function isConfiguredAgentRuntimeAuthState(state) {
+    return state === "connected" || state === "partial";
+}
+export function aggregateAgentRuntimeAuthState(providers, supported) {
+    if (!supported)
+        return "unsupported";
+    if (providers.length === 0)
+        return "failed";
+    const states = new Set(providers.map((provider) => provider.state));
+    if (states.size === 1)
+        return providers[0].state;
+    if (states.has("pending"))
+        return "pending";
+    return "partial";
+}

package/dist/agent-runtime/capabilities.js

@@ -0,0 +1,221 @@
+import { AGENT_RUNTIME_AUTH_COMPLETION_MODES, AGENT_RUNTIME_AUTH_METHOD_IDS, } from "./auth.js";
+const BOOLEAN_CAPABILITY_PATHS = [
+    "lifecycle.persistent",
+    "lifecycle.lazyBinding",
+    "lifecycle.resume",
+    "lifecycle.attach",
+    "lifecycle.listNativeSessions",
+    "lifecycle.fork",
+    "lifecycle.clone",
+    "lifecycle.tree",
+    "input.text",
+    "input.images",
+    "input.audio",
+    "input.steering",
+    "input.structuredOutput",
+    "output.assistantDeltas",
+    "output.reasoning",
+    "output.toolEvents",
+    "output.usage",
+    "output.plans",
+    "output.diffs",
+    "output.rawNativeEvents",
+    "mcp.statusInspection",
+    "auth.status",
+    "auth.cancel",
+    "auth.logout",
+    "models.catalog",
+    "models.switchInSession",
+    "reasoning.supported",
+    "approvals.supported",
+    "approvals.structuredUserInput",
+    "maintenance.compaction",
+    "maintenance.contextUsage",
+    "maintenance.history",
+    "maintenance.health",
+];
+const DELIVERY_CAPABILITY_PATHS = [
+    "tools.piboManaged",
+    "tools.nativeToolInspection",
+    "tools.nativeToolYielding",
+    "mcp.externalServers",
+    "skills",
+    "context",
+];
+function readPath(value, path) {
+    let current = value;
+    for (const segment of path.split(".")) {
+        if (!current || typeof current !== "object" || Array.isArray(current))
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function validateDelivery(path, value, errors) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        errors.push(`${path} must be a capability-delivery object`);
+        return;
+    }
+    const delivery = value;
+    const support = delivery.support;
+    if (!["unsupported", "native", "direct", "mcp", "materialized", "degraded"].includes(String(support))) {
+        errors.push(`${path}.support is invalid`);
+        return;
+    }
+    if ((support === "unsupported" || support === "degraded") && (typeof delivery.reason !== "string" || !delivery.reason.trim())) {
+        errors.push(`${path}.reason must explain ${support} support`);
+    }
+    if (support === "degraded" && (typeof delivery.mode !== "string" || !delivery.mode.trim())) {
+        errors.push(`${path}.mode is required for degraded support`);
+    }
+    if (support === "mcp") {
+        const transports = delivery.transports;
+        if (!Array.isArray(transports) || transports.length === 0 || transports.some((item) => item !== "streamable-http" && item !== "stdio")) {
+            errors.push(`${path}.transports must contain supported MCP transports`);
+        }
+    }
+    if (support === "materialized") {
+        const modes = delivery.modes;
+        if (!Array.isArray(modes) || modes.length === 0 || modes.some((item) => typeof item !== "string" || !item.trim())) {
+            errors.push(`${path}.modes must contain at least one non-empty mode`);
+        }
+    }
+}
+export function validateAgentRuntimeCapabilities(value) {
+    const errors = [];
+    for (const path of BOOLEAN_CAPABILITY_PATHS) {
+        if (typeof readPath(value, path) !== "boolean")
+            errors.push(`${path} must be boolean`);
+    }
+    for (const path of DELIVERY_CAPABILITY_PATHS)
+        validateDelivery(path, readPath(value, path), errors);
+    const persistent = readPath(value, "lifecycle.persistent");
+    for (const path of ["lifecycle.resume", "lifecycle.attach"]) {
+        if (readPath(value, path) === true && persistent !== true)
+            errors.push(`${path} requires lifecycle.persistent`);
+    }
+    const reasoningSupported = readPath(value, "reasoning.supported");
+    const reasoningValues = readPath(value, "reasoning.values");
+    if (reasoningValues !== undefined) {
+        if (!Array.isArray(reasoningValues) || reasoningValues.some((item) => typeof item !== "string" || !item.trim())) {
+            errors.push("reasoning.values must be an array of non-empty strings");
+        }
+        else if (new Set(reasoningValues).size !== reasoningValues.length) {
+            errors.push("reasoning.values must not contain duplicates");
+        }
+    }
+    if (reasoningSupported === false && Array.isArray(reasoningValues) && reasoningValues.length > 0) {
+        errors.push("reasoning.values must be omitted or empty when reasoning is unsupported");
+    }
+    const authMethods = readPath(value, "auth.methods");
+    if (!Array.isArray(authMethods)) {
+        errors.push("auth.methods must be an array");
+    }
+    else {
+        const seen = new Set();
+        for (const [index, method] of authMethods.entries()) {
+            if (!method || typeof method !== "object" || Array.isArray(method)) {
+                errors.push(`auth.methods[${index}] must be an auth-method object`);
+                continue;
+            }
+            const record = method;
+            if (!AGENT_RUNTIME_AUTH_METHOD_IDS.includes(record.id)) {
+                errors.push(`auth.methods[${index}].id is invalid`);
+            }
+            else if (seen.has(String(record.id))) {
+                errors.push(`auth.methods contains duplicate method "${String(record.id)}"`);
+            }
+            else {
+                seen.add(String(record.id));
+            }
+            if (!AGENT_RUNTIME_AUTH_COMPLETION_MODES.includes(record.completion)) {
+                errors.push(`auth.methods[${index}].completion is invalid`);
+            }
+        }
+    }
+    const authScope = readPath(value, "auth.credentialScope");
+    if (authScope !== "runtime-instance" && authScope !== "adapter-shared") {
+        errors.push("auth.credentialScope must be runtime-instance or adapter-shared");
+    }
+    const authStatus = readPath(value, "auth.status");
+    if (Array.isArray(authMethods) && authMethods.length > 0 && authStatus !== true) {
+        errors.push("auth.methods requires auth.status");
+    }
+    if ((readPath(value, "auth.cancel") === true || readPath(value, "auth.logout") === true) && authStatus !== true) {
+        errors.push("auth.cancel and auth.logout require auth.status");
+    }
+    const optionsSchema = readPath(value, "models.optionsSchema");
+    if (optionsSchema !== undefined && (!optionsSchema || typeof optionsSchema !== "object" || Array.isArray(optionsSchema))) {
+        errors.push("models.optionsSchema must be a JSON Schema object");
+    }
+    return errors;
+}
+export function unsupportedAgentRuntimeCapability(reason) {
+    return { support: "unsupported", reason };
+}
+export function createMinimalAgentRuntimeCapabilities() {
+    const unavailable = unsupportedAgentRuntimeCapability("This runtime adapter does not provide this capability.");
+    return {
+        lifecycle: {
+            persistent: false,
+            lazyBinding: false,
+            resume: false,
+            attach: false,
+            listNativeSessions: false,
+            fork: false,
+            clone: false,
+            tree: false,
+        },
+        input: {
+            text: true,
+            images: false,
+            audio: false,
+            steering: false,
+            structuredOutput: false,
+        },
+        output: {
+            assistantDeltas: true,
+            reasoning: false,
+            toolEvents: false,
+            usage: false,
+            plans: false,
+            diffs: false,
+            rawNativeEvents: false,
+        },
+        tools: {
+            piboManaged: unavailable,
+            nativeToolInspection: unavailable,
+            nativeToolYielding: unavailable,
+        },
+        mcp: {
+            externalServers: unavailable,
+            statusInspection: false,
+        },
+        skills: unavailable,
+        context: unavailable,
+        auth: {
+            status: false,
+            methods: [],
+            cancel: false,
+            logout: false,
+            credentialScope: "runtime-instance",
+        },
+        models: {
+            catalog: false,
+            switchInSession: false,
+        },
+        reasoning: {
+            supported: false,
+        },
+        approvals: {
+            supported: false,
+            structuredUserInput: false,
+        },
+        maintenance: {
+            compaction: false,
+            contextUsage: false,
+            history: false,
+            health: true,
+        },
+    };
+}

package/dist/agent-runtime/context-build.js

@@ -0,0 +1,313 @@
+import { InitialSessionContext } from "../core/profiles.js";
+export function profileWithRuntimeInstance(profile, runtimeInstanceId) {
+    if (profile.runtimeInstanceId === runtimeInstanceId)
+        return profile;
+    return new InitialSessionContext({
+        profileName: profile.profileName,
+        runtimeInstanceId,
+        runtimeOptions: profile.runtimeOptions,
+        sessionId: profile.sessionId,
+        parentSessionId: profile.parentSessionId,
+        model: profile.model,
+        mainModel: profile.mainModel,
+        subagentModel: profile.subagentModel,
+        thinkingLevel: profile.thinkingLevel,
+        mainThinkingLevel: profile.mainThinkingLevel,
+        subagentThinkingLevel: profile.subagentThinkingLevel,
+        fast: profile.fast,
+        mainFast: profile.mainFast,
+        subagentFast: profile.subagentFast,
+        skills: profile.skills,
+        tools: profile.tools,
+        subagents: profile.subagents,
+        mcpServers: profile.mcpServers,
+        piPackages: profile.piPackages,
+        contextFiles: profile.contextFiles,
+        builtinTools: profile.builtinTools,
+        builtinToolNames: profile.builtinToolNames,
+        autoContextFiles: profile.autoContextFiles,
+        toolPackages: profile.toolPackages,
+    });
+}
+export function uniqueRuntimeDiagnostics(diagnostics) {
+    const seen = new Set();
+    return diagnostics.filter((diagnostic) => {
+        const key = `${diagnostic.severity}:${diagnostic.code}:${diagnostic.message}:${diagnostic.path ?? ""}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+export function buildPortableRuntimeContextSnapshot(input) {
+    const profile = input.profile;
+    const nodes = [];
+    const addNode = (node) => nodes.push({ ...node, order: nodes.length });
+    addNode({
+        id: "runtime",
+        kind: "metadata",
+        title: "Agent Runtime",
+        source: "runtime",
+        state: input.runtime.available ? "active" : "error",
+        badges: [input.runtime.adapterId.toUpperCase(), input.runtime.available ? "AVAILABLE" : "UNAVAILABLE"],
+        metadata: {
+            runtimeInstanceId: input.runtime.runtimeInstanceId,
+            adapterId: input.runtime.adapterId,
+            transport: input.runtime.transport,
+            bindingState: input.runtime.bindingState,
+            protocol: input.runtime.protocol?.name,
+            runtimeOptionKeys: Object.keys(profile.runtimeOptions),
+        },
+        payloadJson: input.runtime.capabilities,
+    });
+    addRuntimeContributionGroup(nodes, "tools", "Pibo Tools and Subagents", [
+        ...profile.tools.filter((tool) => tool.enabled !== false).map((tool) => tool.name),
+        ...profile.subagents.filter((subagent) => subagent.enabled !== false).map((subagent) => `subagent:${subagent.name} -> ${subagent.targetProfile}`),
+        ...(profile.toolPackages.goalControl !== false ? ["package:pibo-goal-control"] : []),
+        ...(profile.toolPackages.runControl === true ? ["package:pibo-run-control"] : []),
+    ], input.runtime.capabilities.tools.piboManaged);
+    addNativeToolInspectionNode(nodes, input.runtime.capabilities.tools.nativeToolInspection);
+    if (profile.toolPackages.runControl === true) {
+        addNativeToolYieldingNode(nodes, input.runtime.capabilities.tools.nativeToolYielding);
+    }
+    if (input.resources) {
+        addRuntimeResourceGroup(nodes, "skills", "Skills", "skill", input.resources.skills.map((skill) => ({
+            id: skill.contributionId,
+            title: skill.name,
+            source: skill.kind === "builtin" ? "library" : skill.kind === "user" ? "custom" : "plugin",
+            path: skill.materializedPath ?? skill.sourcePath,
+            metadata: { kind: skill.kind },
+        })), input.resources);
+        addRuntimeResourceGroup(nodes, "context", "Context", "context_file", input.resources.context.map((contribution) => ({
+            id: contribution.id,
+            title: contribution.label,
+            source: contribution.source === "pibo-product" ? "pibo"
+                : contribution.source === "generated" ? "generated"
+                    : contribution.source,
+            path: contribution.materializedPath ?? contribution.path ?? contribution.sourcePath,
+            bytes: contribution.byteSize,
+            metadata: { kind: contribution.kind, intent: contribution.intent, required: contribution.required },
+        })), input.resources);
+        addRuntimeResourceGroup(nodes, "mcp", "External MCP Servers", "runtime_extension", input.resources.mcpServers.map((server) => ({
+            id: server.contributionId,
+            title: server.name,
+            source: "profile",
+            metadata: {
+                transport: server.transport,
+                connectionStatus: server.status,
+                toolNames: server.tools.map((tool) => tool.name),
+                resourceUris: server.resources.map((resource) => resource.uri),
+                resourceTemplates: server.resourceTemplates.map((resource) => resource.uriTemplate),
+                secretEnvironmentKeys: server.secretEnvironmentKeys,
+            },
+        })), input.resources);
+    }
+    else {
+        addRuntimeContributionGroup(nodes, "skills", "Skills", profile.skills.filter((skill) => skill.enabled !== false).map((skill) => skill.name), input.runtime.capabilities.skills);
+        addRuntimeContributionGroup(nodes, "context", "Context", [
+            ...(profile.autoContextFiles ? ["automatic:AGENTS.md/CLAUDE.md"] : []),
+            ...profile.contextFiles.filter((file) => file.enabled !== false).map((file) => file.key ?? file.path),
+        ], input.runtime.capabilities.context);
+        addRuntimeContributionGroup(nodes, "mcp", "External MCP Servers", [...profile.mcpServers], input.runtime.capabilities.mcp.externalServers);
+    }
+    if (profile.piPackages.some((pkg) => pkg.enabled !== false)) {
+        addNode({
+            id: "adapter-packages",
+            kind: "runtime_extension",
+            title: "Adapter Packages",
+            source: "profile",
+            state: input.runtime.adapterId === "pi" ? "active" : "warning",
+            badges: ["PI PACKAGES"],
+            notes: input.runtime.adapterId === "pi" ? undefined : ["Pi packages are adapter-specific and require explicit support from the selected runtime."],
+            metadata: { packages: profile.piPackages.filter((pkg) => pkg.enabled !== false).map((pkg) => pkg.id) },
+        });
+    }
+    addNode({
+        id: "model-options",
+        kind: "metadata",
+        title: "Model and Runtime Options",
+        source: "profile",
+        state: "active",
+        metadata: {
+            activeModel: input.activeModel,
+            mainModel: profile.mainModel,
+            subagentModel: profile.subagentModel,
+            mainThinkingLevel: profile.mainThinkingLevel ?? profile.thinkingLevel,
+            subagentThinkingLevel: profile.subagentThinkingLevel ?? profile.thinkingLevel,
+            mainFast: profile.mainFast ?? profile.fast,
+            subagentFast: profile.subagentFast ?? profile.fast,
+            builtinTools: profile.builtinTools,
+            builtinToolNames: profile.builtinToolNames,
+        },
+    });
+    for (const [index, diagnostic] of input.runtime.diagnostics.entries()) {
+        addNode({
+            id: `runtime-diagnostic-${index}`,
+            kind: "diagnostic",
+            title: diagnostic.code,
+            source: "runtime",
+            state: diagnostic.severity === "error" ? "error" : diagnostic.severity === "warning" ? "warning" : "active",
+            badges: [diagnostic.severity.toUpperCase()],
+            hydratedText: diagnostic.message,
+            metadata: diagnostic.path ? { path: diagnostic.path } : undefined,
+        });
+    }
+    for (const [index, diagnostic] of (input.resources?.diagnostics ?? []).entries()) {
+        addNode({
+            id: `resource-diagnostic-${index}`,
+            kind: "diagnostic",
+            title: diagnostic.code,
+            source: "runtime",
+            state: diagnostic.severity === "error" ? "error" : diagnostic.severity === "warning" ? "warning" : "active",
+            badges: [diagnostic.severity.toUpperCase(), "RESOURCE"],
+            hydratedText: diagnostic.message,
+            metadata: diagnostic.contributionId ? { contributionId: diagnostic.contributionId } : undefined,
+        });
+    }
+    const resourceDiagnostics = input.resources?.diagnostics ?? [];
+    const warnings = input.runtime.diagnostics.filter((diagnostic) => diagnostic.severity === "warning").length
+        + resourceDiagnostics.filter((diagnostic) => diagnostic.severity === "warning").length;
+    const errors = input.runtime.diagnostics.filter((diagnostic) => diagnostic.severity === "error").length
+        + resourceDiagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
+    return {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        profileName: profile.profileName,
+        piboSessionId: input.piboSessionId,
+        piboRoomId: input.piboRoomId,
+        cwd: input.cwd,
+        activeModel: input.activeModel,
+        runtime: input.runtime,
+        summary: {
+            topLevelNodes: nodes.length,
+            totalNodes: nodes.reduce((count, node) => count + 1 + (node.children?.length ?? 0), 0),
+            estimatedTokens: 0,
+            warnings,
+            errors,
+        },
+        nodes,
+        diagnostics: [
+            ...input.runtime.diagnostics.map((diagnostic) => ({ type: diagnostic.severity, message: diagnostic.message })),
+            ...resourceDiagnostics.map((diagnostic) => ({ type: diagnostic.severity, message: diagnostic.message })),
+        ],
+    };
+}
+function addNativeToolInspectionNode(nodes, delivery) {
+    const supported = delivery.support !== "unsupported";
+    const mode = runtimeDeliveryMode(delivery);
+    const reason = delivery.support === "unsupported" || delivery.support === "degraded" ? delivery.reason : undefined;
+    nodes.push({
+        id: "tools/native-inspection",
+        order: nodes.length,
+        kind: "runtime_extension",
+        title: "Harness-Native Tool Inspection",
+        source: "runtime",
+        state: supported ? delivery.support === "degraded" ? "warning" : "active" : "warning",
+        badges: [mode.toUpperCase()],
+        metadata: { deliveryMode: mode },
+        notes: [
+            "Harness-native tools remain owned and executed by the selected runtime.",
+            ...(reason ? [reason] : []),
+        ],
+    });
+}
+function addNativeToolYieldingNode(nodes, delivery) {
+    const supported = delivery.support !== "unsupported";
+    const mode = runtimeDeliveryMode(delivery);
+    const reason = delivery.support === "unsupported" || delivery.support === "degraded" ? delivery.reason : undefined;
+    nodes.push({
+        id: "tools/native-yielding",
+        order: nodes.length,
+        kind: "runtime_extension",
+        title: "Private Harness-Native Tool Yielding",
+        source: "runtime",
+        state: supported ? delivery.support === "degraded" ? "warning" : "active" : "warning",
+        badges: [mode.toUpperCase()],
+        metadata: { deliveryMode: mode, piboManagedToolYieldingUnaffected: true },
+        notes: [
+            "pibo_run_start can always wrap selected Pibo-managed tools when Pibo tool delivery is supported.",
+            ...(reason ? [reason] : []),
+        ],
+    });
+}
+function addRuntimeResourceGroup(nodes, id, title, kind, items, resources) {
+    const reports = new Map(resources.delivery.map((report) => [report.contributionId, report]));
+    const children = items.map((item, index) => {
+        const report = reports.get(item.id);
+        const status = report?.status ?? "failed";
+        return {
+            id: `${id}/${index}`,
+            parentId: id,
+            order: index,
+            kind,
+            title: item.title,
+            source: item.source ?? "profile",
+            state: status === "failed" || status === "unsupported"
+                ? "error"
+                : status === "degraded"
+                    ? "warning"
+                    : "active",
+            badges: [status.toUpperCase(), ...(report ? [report.mode.toUpperCase(), report.fidelity.toUpperCase()] : [])],
+            ...(item.path ? { path: item.path } : {}),
+            ...(item.bytes !== undefined ? { bytes: item.bytes } : {}),
+            metadata: {
+                ...item.metadata,
+                contributionId: item.id,
+                deliveryStatus: status,
+                deliveryMode: report?.mode,
+                fidelity: report?.fidelity,
+                target: report?.target,
+            },
+            notes: report?.diagnostic ? [report.diagnostic] : undefined,
+        };
+    });
+    const hasError = children.some((child) => child.state === "error");
+    const hasWarning = children.some((child) => child.state === "warning");
+    nodes.push({
+        id,
+        order: nodes.length,
+        kind: id === "skills" ? "skills" : id === "context" ? "context_files" : "runtime_extension",
+        title,
+        source: "profile",
+        state: hasError ? "error" : hasWarning ? "warning" : children.length > 0 ? "active" : "disabled",
+        badges: [hasError ? "FAILED" : hasWarning ? "DEGRADED" : children.length > 0 ? "DELIVERED" : "EMPTY"],
+        metadata: { selectedCount: children.length, sessionGeneration: resources.sessionGeneration },
+        children,
+    });
+}
+function addRuntimeContributionGroup(nodes, id, title, items, delivery) {
+    const state = delivery.support === "unsupported" ? "error" : delivery.support === "degraded" ? "warning" : items.length > 0 ? "active" : "disabled";
+    const reason = delivery.support === "unsupported" || delivery.support === "degraded" ? delivery.reason : undefined;
+    const mode = runtimeDeliveryMode(delivery);
+    nodes.push({
+        id,
+        order: nodes.length,
+        kind: id === "tools" ? "tool_surface" : id === "skills" ? "skills" : id === "context" ? "context_files" : "runtime_extension",
+        title,
+        source: "profile",
+        state,
+        badges: [mode.toUpperCase()],
+        metadata: { deliveryMode: mode, selectedCount: items.length },
+        notes: reason ? [reason] : undefined,
+        children: items.map((item, index) => ({
+            id: `${id}/${index}`,
+            parentId: id,
+            order: index,
+            kind: id === "tools" ? "tool" : id === "skills" ? "skill" : id === "context" ? "context_file" : "runtime_extension",
+            title: item,
+            source: "profile",
+            state: delivery.support === "unsupported" ? "error" : delivery.support === "degraded" ? "warning" : "active",
+            badges: [mode.toUpperCase()],
+            notes: reason ? [reason] : undefined,
+        })),
+    });
+}
+function runtimeDeliveryMode(delivery) {
+    if (delivery.support === "mcp")
+        return `mcp:${delivery.transports.join(",")}`;
+    if (delivery.support === "materialized")
+        return `materialized:${delivery.modes.join(",")}`;
+    if (delivery.support === "degraded")
+        return `degraded:${delivery.mode}`;
+    return delivery.support;
+}

package/dist/agent-runtime/contract.js

@@ -0,0 +1,45 @@
+import { AgentRuntimeContractError } from "./errors.js";
+export function validateAgentRuntimeSessionContract(session) {
+    const errors = [];
+    const capabilities = session.capabilities;
+    const controls = session.controls;
+    const requireMethod = (enabled, path, method) => {
+        if (enabled && typeof controls?.[method] !== "function") {
+            errors.push(`${path} requires controls.${String(method)}()`);
+        }
+    };
+    if (capabilities.input.steering && typeof session.steer !== "function") {
+        errors.push("input.steering requires session.steer()");
+    }
+    requireMethod(capabilities.lifecycle.listNativeSessions, "lifecycle.listNativeSessions", "listSessions");
+    requireMethod(capabilities.lifecycle.fork, "lifecycle.fork", "forkSession");
+    requireMethod(capabilities.lifecycle.clone, "lifecycle.clone", "cloneSession");
+    requireMethod(capabilities.lifecycle.tree, "lifecycle.tree", "getSessionTree");
+    requireMethod(capabilities.lifecycle.tree, "lifecycle.tree", "navigateSessionTree");
+    requireMethod(capabilities.models.switchInSession, "models.switchInSession", "setModel");
+    requireMethod(capabilities.reasoning.supported, "reasoning.supported", "getReasoning");
+    requireMethod(capabilities.reasoning.supported, "reasoning.supported", "setReasoning");
+    requireMethod(capabilities.approvals.supported, "approvals.supported", "respondToApproval");
+    requireMethod(capabilities.approvals.structuredUserInput, "approvals.structuredUserInput", "respondToUserInput");
+    requireMethod(capabilities.maintenance.compaction, "maintenance.compaction", "compact");
+    const binding = session.getBinding();
+    if (binding.adapterId !== session.adapterId) {
+        errors.push(`binding.adapterId "${binding.adapterId}" does not match session.adapterId "${session.adapterId}"`);
+    }
+    if (binding.runtimeInstanceId !== session.runtimeInstanceId) {
+        errors.push(`binding.runtimeInstanceId "${binding.runtimeInstanceId}" does not match session.runtimeInstanceId "${session.runtimeInstanceId}"`);
+    }
+    if (binding.state === "bound" && !binding.nativeSessionId) {
+        errors.push("a bound session requires binding.nativeSessionId");
+    }
+    if (binding.state === "unbound" && binding.nativeSessionId) {
+        errors.push("an unbound session must not expose binding.nativeSessionId");
+    }
+    return errors;
+}
+export function assertAgentRuntimeSessionContract(session) {
+    const errors = validateAgentRuntimeSessionContract(session);
+    if (errors.length > 0) {
+        throw new AgentRuntimeContractError(session.runtimeInstanceId, `Agent runtime session contract failed: ${errors.join("; ")}`);
+    }
+}

package/dist/agent-runtime/errors.js

@@ -0,0 +1,57 @@
+export class AgentRuntimeRegistrationError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "AgentRuntimeRegistrationError";
+    }
+}
+export class AgentRuntimeContractError extends Error {
+    runtimeInstanceId;
+    constructor(runtimeInstanceId, message, options) {
+        super(message, options);
+        this.runtimeInstanceId = runtimeInstanceId;
+        this.name = "AgentRuntimeContractError";
+    }
+}
+export class AgentRuntimeUnavailableError extends Error {
+    runtimeInstanceId;
+    constructor(runtimeInstanceId, message = `Agent runtime instance "${runtimeInstanceId}" is unavailable.`, options) {
+        super(message, options);
+        this.runtimeInstanceId = runtimeInstanceId;
+        this.name = "AgentRuntimeUnavailableError";
+    }
+}
+export class AgentRuntimeCapabilityUnavailableError extends Error {
+    capability;
+    runtimeInstanceId;
+    constructor(capability, runtimeInstanceId, reason, options) {
+        super(reason
+            ?? (runtimeInstanceId
+                ? `Agent runtime instance "${runtimeInstanceId}" does not support ${capability}.`
+                : `The active agent runtime does not support ${capability}.`), options);
+        this.capability = capability;
+        this.runtimeInstanceId = runtimeInstanceId;
+        this.name = "AgentRuntimeCapabilityUnavailableError";
+    }
+}
+export class AgentRuntimeAuthError extends Error {
+    code;
+    retryable;
+    constructor(code, message, retryable = false, options) {
+        super(message, options);
+        this.code = code;
+        this.retryable = retryable;
+        this.name = "AgentRuntimeAuthError";
+    }
+}
+export class AgentRuntimeBindingMissingError extends Error {
+    piboSessionId;
+    runtimeInstanceId;
+    nativeSessionId;
+    constructor(piboSessionId, runtimeInstanceId, nativeSessionId, options) {
+        super(`The native session${nativeSessionId ? ` "${nativeSessionId}"` : ""} for Pibo session "${piboSessionId}" is missing from runtime instance "${runtimeInstanceId}".`, options);
+        this.piboSessionId = piboSessionId;
+        this.runtimeInstanceId = runtimeInstanceId;
+        this.nativeSessionId = nativeSessionId;
+        this.name = "AgentRuntimeBindingMissingError";
+    }
+}

package/dist/agent-runtime/events.js

@@ -0,0 +1 @@
+export {};

package/dist/agent-runtime/history.js

@@ -0,0 +1 @@
+export {};