@pasko70/pibo 2.1.1 → 2.2.0

package/dist/agent-runtime/capabilities.js

@@ -21,6 +21,13 @@ const BOOLEAN_CAPABILITY_PATHS = [
     "output.diffs",
     "output.rawNativeEvents",
     "mcp.statusInspection",
+    "contextDiscovery.supported",
+    "contextDiscovery.configurable",
+    "contextDiscovery.enabledByDefault",
+    "nativeSubagents.supported",
+    "nativeSubagents.configurable",
+    "nativeSubagents.enabledByDefault",
+    "historyImport",
     "auth.status",
     "auth.cancel",
     "auth.logout",
@@ -51,6 +58,13 @@ function readPath(value, path) {
     }
     return current;
 }
+function safeDeclaredRelativePath(value) {
+    const normalized = value.replaceAll("\\", "/");
+    return !normalized.startsWith("/")
+        && !/^[A-Za-z]:/.test(normalized)
+        && !normalized.includes("\0")
+        && normalized.split("/").every((segment) => segment !== "..");
+}
 function validateDelivery(path, value, errors) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         errors.push(`${path} must be a capability-delivery object`);
@@ -107,6 +121,49 @@ export function validateAgentRuntimeCapabilities(value) {
     if (reasoningSupported === false && Array.isArray(reasoningValues) && reasoningValues.length > 0) {
         errors.push("reasoning.values must be omitted or empty when reasoning is unsupported");
     }
+    for (const feature of ["contextDiscovery", "nativeSubagents"]) {
+        const supported = readPath(value, `${feature}.supported`);
+        const configurable = readPath(value, `${feature}.configurable`);
+        const enabledByDefault = readPath(value, `${feature}.enabledByDefault`);
+        if (configurable === true && supported !== true) {
+            errors.push(`${feature}.configurable requires ${feature}.supported`);
+        }
+        if (enabledByDefault === true && supported !== true) {
+            errors.push(`${feature}.enabledByDefault requires ${feature}.supported`);
+        }
+    }
+    const contextDiscoveryStrategy = readPath(value, "contextDiscovery.strategy");
+    if (contextDiscoveryStrategy !== undefined
+        && !["filesystem-ancestors", "codex-project", "omp-project"].includes(String(contextDiscoveryStrategy))) {
+        errors.push("contextDiscovery.strategy must be filesystem-ancestors, codex-project, or omp-project when provided");
+    }
+    if (contextDiscoveryStrategy !== undefined && readPath(value, "contextDiscovery.supported") !== true) {
+        errors.push("contextDiscovery.strategy requires contextDiscovery.supported");
+    }
+    for (const field of ["knownFileNames", "knownUserRelativePaths", "knownCwdRelativePaths", "knownRelativePaths", "knownAncestorRelativePaths"]) {
+        const knownContextPaths = readPath(value, `contextDiscovery.${field}`);
+        if (knownContextPaths === undefined)
+            continue;
+        if (!Array.isArray(knownContextPaths)) {
+            errors.push(`contextDiscovery.${field} must be an array of non-empty strings when provided`);
+            continue;
+        }
+        if (knownContextPaths.some((name) => typeof name !== "string" || !name.trim())) {
+            errors.push(`contextDiscovery.${field} must be an array of non-empty strings when provided`);
+        }
+        else if (new Set(knownContextPaths).size !== knownContextPaths.length) {
+            errors.push(`contextDiscovery.${field} must not contain duplicates`);
+        }
+        else if (field === "knownFileNames" && knownContextPaths.some((name) => name.includes("/") || name.includes("\\") || name === "." || name === "..")) {
+            errors.push("contextDiscovery.knownFileNames entries must be plain filenames");
+        }
+        else if (field !== "knownFileNames" && knownContextPaths.some((path) => !safeDeclaredRelativePath(path))) {
+            errors.push(`contextDiscovery.${field} entries must be safe relative paths`);
+        }
+        if (readPath(value, "contextDiscovery.supported") !== true && knownContextPaths.length > 0) {
+            errors.push(`contextDiscovery.${field} requires contextDiscovery.supported`);
+        }
+    }
     const authMethods = readPath(value, "auth.methods");
     if (!Array.isArray(authMethods)) {
         errors.push("auth.methods must be an array");
@@ -193,6 +250,17 @@ export function createMinimalAgentRuntimeCapabilities() {
         },
         skills: unavailable,
         context: unavailable,
+        contextDiscovery: {
+            supported: false,
+            configurable: false,
+            enabledByDefault: false,
+        },
+        nativeSubagents: {
+            supported: false,
+            configurable: false,
+            enabledByDefault: false,
+        },
+        historyImport: false,
         auth: {
             status: false,
             methods: [],

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

@@ -5,12 +5,12 @@ export function profileWithRuntimeInstance(profile, runtimeInstanceId) {
     return new InitialSessionContext({
         profileName: profile.profileName,
         runtimeInstanceId,
-        runtimeOptions: profile.runtimeOptions,
+        runtimeOptions: {},
         sessionId: profile.sessionId,
         parentSessionId: profile.parentSessionId,
-        model: profile.model,
-        mainModel: profile.mainModel,
-        subagentModel: profile.subagentModel,
+        model: undefined,
+        mainModel: undefined,
+        subagentModel: undefined,
         thinkingLevel: profile.thinkingLevel,
         mainThinkingLevel: profile.mainThinkingLevel,
         subagentThinkingLevel: profile.subagentThinkingLevel,
@@ -26,6 +26,7 @@ export function profileWithRuntimeInstance(profile, runtimeInstanceId) {
         builtinTools: profile.builtinTools,
         builtinToolNames: profile.builtinToolNames,
         autoContextFiles: profile.autoContextFiles,
+        nativeSubagents: undefined,
         toolPackages: profile.toolPackages,
     });
 }
@@ -105,7 +106,12 @@ export function buildPortableRuntimeContextSnapshot(input) {
     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"] : []),
+            ...(input.runtime.capabilities.contextDiscovery.supported
+                && (input.runtime.capabilities.contextDiscovery.configurable
+                    ? profile.autoContextFiles
+                    : input.runtime.capabilities.contextDiscovery.enabledByDefault)
+                ? ["automatic:runtime project context discovery"]
+                : []),
             ...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);
@@ -138,6 +144,8 @@ export function buildPortableRuntimeContextSnapshot(input) {
             subagentFast: profile.subagentFast ?? profile.fast,
             builtinTools: profile.builtinTools,
             builtinToolNames: profile.builtinToolNames,
+            nativeSubagents: profile.nativeSubagents
+                ?? input.runtime.capabilities.nativeSubagents.enabledByDefault,
         },
     });
     for (const [index, diagnostic] of input.runtime.diagnostics.entries()) {

package/dist/agent-runtime/portable-history.js

@@ -0,0 +1,526 @@
+import { createHash } from "node:crypto";
+import { redactSensitiveText, redactSensitiveValue } from "../core/sensitive-data-redaction.js";
+export const PORTABLE_HISTORY_HANDOFF_METADATA_KEY = "portableHistoryHandoff";
+export const PORTABLE_HISTORY_LAST_IMPORT_METADATA_KEY = "portableHistoryLastImport";
+const PORTABLE_HISTORY_VERSION = 1;
+const MAX_SOURCE_ROWS = 4_000;
+const MAX_HISTORY_ENTRIES = 1_000;
+const MAX_HISTORY_BYTES = 1024 * 1024;
+const MAX_ENTRY_BYTES = 256 * 1024;
+const MAX_HISTORY_ENVELOPE_RESERVE_BYTES = 16 * 1024;
+function validBoundedIdentifier(value) {
+    return typeof value === "string" && value.trim().length > 0 && value.length <= 256;
+}
+function validTimestamp(value) {
+    return typeof value === "string" && value.length <= 128 && Number.isFinite(Date.parse(value));
+}
+function parseObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function jsonValue(value) {
+    if (value === undefined)
+        return undefined;
+    try {
+        return JSON.parse(JSON.stringify(redactSensitiveValue(value)));
+    }
+    catch {
+        return undefined;
+    }
+}
+function boundedIdentifierText(value, fallback, maxLength = 512) {
+    const normalized = value.trim();
+    const redacted = redactSensitiveText(normalized).replace(/[\r\n]+/g, " ").trim();
+    const needsHash = redacted !== normalized || redacted.length > maxLength;
+    const suffix = needsHash ? `-${createHash("sha256").update(value).digest("hex").slice(0, 12)}` : "";
+    const selected = (redacted || fallback).slice(0, Math.max(1, maxLength - suffix.length));
+    return `${selected}${suffix}`;
+}
+function optionalBoundedIdentifierText(value) {
+    return value ? boundedIdentifierText(value, "portable-id") : undefined;
+}
+function boundedText(value, maxBytes = MAX_ENTRY_BYTES) {
+    if (Buffer.byteLength(value, "utf8") <= maxBytes)
+        return value;
+    const suffix = "\n\n[Portable history entry truncated by Pibo.]";
+    const suffixBytes = Buffer.byteLength(suffix, "utf8");
+    const buffer = Buffer.from(value, "utf8");
+    return `${buffer.subarray(0, Math.max(0, maxBytes - suffixBytes)).toString("utf8")}${suffix}`;
+}
+function stringContent(entry) {
+    if (entry.type !== "message")
+        return entry.name;
+    if (typeof entry.content === "string")
+        return entry.content;
+    return entry.content.map((part) => {
+        if (part.type === "text" || part.type === "reasoning")
+            return part.text;
+        return `${part.toolName}:${JSON.stringify(part.input ?? null)}`;
+    }).join("\n");
+}
+function entryBytes(entry) {
+    return Buffer.byteLength(JSON.stringify(entry), "utf8");
+}
+function historyRole(value) {
+    return value === "user" || value === "assistant" || value === "system" ? value : undefined;
+}
+function historyStatus(value) {
+    if (value === "running" || value === "streaming" || value === "in_progress")
+        return "running";
+    if (value === "error" || value === "failed")
+        return "error";
+    return "complete";
+}
+export class PiboDataPortableHistoryProvider {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    createCheckpoint(piboSessionId) {
+        const row = this.store.db.prepare(`
+			SELECT COALESCE(MAX(session_sequence), 0) AS max_sequence
+			FROM event_log
+			WHERE session_id = ?
+		`).get(piboSessionId);
+        return {
+            maxSessionSequence: Number(row.max_sequence ?? 0),
+            createdAt: new Date().toISOString(),
+        };
+    }
+    read(input) {
+        const messages = this.readMessages(input.piboSession.id, input.checkpoint, this.readRoutedUserMessages(input.piboSession.id, input.checkpoint));
+        const tools = this.readToolEntries(input.piboSession.id, input.checkpoint);
+        const nonPortableCount = this.nonPortableEntryCount(input.piboSession.id, input.checkpoint);
+        const modelEntries = [...messages, ...tools]
+            .sort((left, right) => (left.sequence ?? 0) - (right.sequence ?? 0) || left.createdAt.localeCompare(right.createdAt));
+        const contextEntry = {
+            id: "portable:pibo-context",
+            type: "message",
+            source: "product",
+            createdAt: input.checkpoint.createdAt,
+            sequence: 0,
+            role: "system",
+            content: [
+                "Pibo portable conversation handoff.",
+                `Pibo Session ID: ${input.piboSession.id}`,
+                `Pibo Room ID: ${typeof input.piboSession.metadata?.chatRoomId === "string" ? input.piboSession.metadata.chatRoomId : "unknown"}`,
+                `Profile: ${input.piboSession.profile}`,
+                `Source runtime: ${input.sourceBinding.runtimeInstanceId} (${input.sourceBinding.adapterId})`,
+                "The following entries are model-relevant product history. Private reasoning and runtime-private metadata are intentionally omitted.",
+            ].join("\n"),
+            status: "complete",
+        };
+        const nonPortableEntry = nonPortableCount > 0
+            ? {
+                id: "portable:nonportable-fallback",
+                type: "message",
+                source: "product",
+                createdAt: input.checkpoint.createdAt,
+                sequence: 0,
+                role: "system",
+                content: `${nonPortableCount} runtime-specific history entr${nonPortableCount === 1 ? "y was" : "ies were"} retained by Pibo but omitted from the portable model context because no safe cross-runtime representation exists.`,
+                status: "complete",
+            }
+            : undefined;
+        const bounded = boundEntries(modelEntries, {
+            maxEntries: MAX_HISTORY_ENTRIES - (nonPortableEntry ? 3 : 2),
+            maxBytes: Math.max(0, MAX_HISTORY_BYTES
+                - entryBytes(contextEntry)
+                - (nonPortableEntry ? entryBytes(nonPortableEntry) : 0)
+                - MAX_HISTORY_ENVELOPE_RESERVE_BYTES),
+        });
+        const retained = [...bounded.entries];
+        let additionallyOmitted = 0;
+        while (true) {
+            const omittedEntries = bounded.omittedEntries + additionallyOmitted;
+            const entries = [contextEntry];
+            if (nonPortableEntry)
+                entries.push(nonPortableEntry);
+            if (omittedEntries > 0) {
+                entries.push({
+                    id: "portable:bounded-fallback",
+                    type: "message",
+                    source: "product",
+                    createdAt: input.checkpoint.createdAt,
+                    sequence: 0,
+                    role: "system",
+                    content: `${omittedEntries} older portable history entr${omittedEntries === 1 ? "y was" : "ies were"} omitted to stay within the bounded cross-runtime handoff limit. The most recent conversation context follows.`,
+                    status: "complete",
+                });
+            }
+            entries.push(...normalizeToolPairs(retained));
+            const history = {
+                version: PORTABLE_HISTORY_VERSION,
+                piboSessionId: input.piboSession.id,
+                sourceRuntimeInstanceId: input.sourceBinding.runtimeInstanceId,
+                sourceAdapterId: input.sourceBinding.adapterId,
+                checkpoint: { ...input.checkpoint },
+                entries,
+                truncated: omittedEntries > 0,
+                omittedEntries,
+            };
+            const serializedBytes = Buffer.byteLength(JSON.stringify(history), "utf8");
+            if (serializedBytes <= MAX_HISTORY_BYTES)
+                return history;
+            if (retained.length === 0) {
+                throw new Error("Portable history metadata exceeds the aggregate handoff limit.");
+            }
+            const excessBytes = serializedBytes - MAX_HISTORY_BYTES;
+            const averageEntryBytes = Math.max(1, Math.floor(retained.reduce((sum, entry) => sum + entryBytes(entry), 0) / retained.length));
+            const removeCount = Math.min(retained.length, Math.max(1, Math.ceil(excessBytes / averageEntryBytes)));
+            retained.splice(0, removeCount);
+            additionallyOmitted += removeCount;
+        }
+    }
+    readMessages(piboSessionId, checkpoint, routedUserMessages) {
+        const rows = this.store.db.prepare(`
+			SELECT m.*, e.session_sequence AS event_sequence
+			FROM chat_messages m
+			LEFT JOIN event_log e ON e.stream_id = m.source_stream_id
+			WHERE m.session_id = ?
+				AND m.role IN ('user', 'assistant', 'system')
+				AND ((e.session_sequence IS NOT NULL AND e.session_sequence <= ?) OR (e.session_sequence IS NULL AND m.created_at <= ?))
+			ORDER BY COALESCE(e.session_sequence, m.sequence) DESC
+			LIMIT ?
+		`).all(piboSessionId, checkpoint.maxSessionSequence, checkpoint.createdAt, MAX_SOURCE_ROWS);
+        return rows.reverse().flatMap((row) => {
+            const role = historyRole(row.role);
+            if (!role)
+                return [];
+            const attributes = parseObject(row.attributes_json);
+            const clientTxnId = typeof attributes.clientTxnId === "string" ? attributes.clientTxnId : undefined;
+            if (role === "user") {
+                if (clientTxnId && !routedUserMessages.turnIds.has(clientTxnId))
+                    return [];
+                if (!clientTxnId && row.source_stream_id !== null && !routedUserMessages.sourceStreamIds.has(row.source_stream_id))
+                    return [];
+            }
+            let text = typeof attributes.inlineText === "string" ? attributes.inlineText : row.content_preview ?? "";
+            if (row.content_payload_ref) {
+                const payload = this.store.payloads.getPayload(row.content_payload_ref);
+                if (payload && payload.byteSize <= MAX_ENTRY_BYTES) {
+                    text = this.store.payloads.readPayloadText(row.content_payload_ref);
+                }
+            }
+            return [{
+                    id: `portable:message:${row.id}`,
+                    type: "message",
+                    source: "product",
+                    createdAt: row.created_at,
+                    sequence: row.event_sequence ?? row.sequence,
+                    turnId: optionalBoundedIdentifierText(row.turn_id),
+                    role,
+                    content: boundedText(redactSensitiveText(text)),
+                    status: historyStatus(row.status),
+                }];
+        });
+    }
+    readRoutedUserMessages(piboSessionId, checkpoint) {
+        const routedRows = this.store.db.prepare(`
+			SELECT DISTINCT turn_id
+			FROM event_log
+			WHERE session_id = ?
+				AND session_sequence <= ?
+				AND turn_id IS NOT NULL
+				AND type IN ('message_queued', 'message_steered', 'message_started')
+		`).all(piboSessionId, checkpoint.maxSessionSequence);
+        const acceptedRows = this.store.db.prepare(`
+			SELECT accepted.stream_id
+			FROM event_log accepted
+			WHERE accepted.session_id = ?
+				AND accepted.type = 'user.message.accepted'
+				AND accepted.session_sequence <= ?
+				AND EXISTS (
+					SELECT 1
+					FROM event_log routed
+					WHERE routed.session_id = accepted.session_id
+						AND routed.session_sequence > accepted.session_sequence
+						AND routed.session_sequence <= ?
+						AND routed.type IN ('message_queued', 'message_steered', 'message_started')
+						AND NOT EXISTS (
+							SELECT 1
+							FROM event_log next_user
+							WHERE next_user.session_id = accepted.session_id
+								AND next_user.type = 'user.message.accepted'
+								AND next_user.session_sequence > accepted.session_sequence
+								AND next_user.session_sequence < routed.session_sequence
+						)
+				)
+		`).all(piboSessionId, checkpoint.maxSessionSequence, checkpoint.maxSessionSequence);
+        return {
+            turnIds: new Set(routedRows.map((row) => row.turn_id)),
+            sourceStreamIds: new Set(acceptedRows.map((row) => row.stream_id)),
+        };
+    }
+    readToolEntries(piboSessionId, checkpoint) {
+        const rows = this.store.db.prepare(`
+			SELECT stream_id, session_sequence, type, turn_id, tool_call_id, payload_ref, preview_text, attributes_json, created_at
+			FROM event_log
+			WHERE session_id = ?
+				AND session_sequence <= ?
+				AND type IN ('tool_call', 'tool_execution_finished')
+			ORDER BY session_sequence DESC
+			LIMIT ?
+		`).all(piboSessionId, checkpoint.maxSessionSequence, MAX_SOURCE_ROWS).reverse();
+        const calls = new Map();
+        const results = new Map();
+        for (const row of rows) {
+            if (!row.tool_call_id)
+                continue;
+            if (row.type === "tool_call") {
+                const attributes = parseObject(row.attributes_json);
+                const existing = calls.get(row.tool_call_id);
+                if (!existing || attributes.argsComplete === true)
+                    calls.set(row.tool_call_id, row);
+            }
+            else {
+                results.set(row.tool_call_id, row);
+            }
+        }
+        const entries = [];
+        for (const [toolCallId, row] of calls) {
+            const attributes = parseObject(row.attributes_json);
+            const portableToolCallId = boundedIdentifierText(toolCallId, `tool-call-${row.stream_id}`);
+            const toolName = boundedIdentifierText(typeof attributes.toolName === "string" ? attributes.toolName : row.preview_text ?? "tool", "tool", 256);
+            const part = {
+                type: "tool_call",
+                toolCallId: portableToolCallId,
+                toolName,
+                input: this.readEventPayload(row),
+            };
+            entries.push({
+                id: `portable:tool-call:${row.stream_id}`,
+                type: "message",
+                source: "product",
+                createdAt: row.created_at,
+                sequence: row.session_sequence,
+                turnId: optionalBoundedIdentifierText(row.turn_id),
+                role: "assistant",
+                content: [part],
+                status: "complete",
+                toolCallId: portableToolCallId,
+                toolName,
+            });
+        }
+        for (const [toolCallId, row] of results) {
+            const attributes = parseObject(row.attributes_json);
+            const portableToolCallId = boundedIdentifierText(toolCallId, `tool-call-${row.stream_id}`);
+            const toolName = boundedIdentifierText(typeof attributes.toolName === "string" ? attributes.toolName : row.preview_text ?? "tool", "tool", 256);
+            const result = this.readEventPayload(row) ?? null;
+            entries.push({
+                id: `portable:tool-result:${row.stream_id}`,
+                type: "message",
+                source: "product",
+                createdAt: row.created_at,
+                sequence: row.session_sequence,
+                turnId: optionalBoundedIdentifierText(row.turn_id),
+                role: "tool",
+                content: boundedText(JSON.stringify(result)),
+                status: attributes.isError === true ? "error" : "complete",
+                toolCallId: portableToolCallId,
+                toolName,
+                result,
+                isError: attributes.isError === true,
+            });
+        }
+        return entries;
+    }
+    readEventPayload(row) {
+        const attributes = parseObject(row.attributes_json);
+        if (attributes.inlinePayload !== undefined)
+            return jsonValue(attributes.inlinePayload);
+        if (!row.payload_ref)
+            return undefined;
+        const payload = this.store.payloads.getPayload(row.payload_ref);
+        if (!payload)
+            return { portableFallback: "Tool payload is no longer available in Pibo history." };
+        if (payload.byteSize > MAX_ENTRY_BYTES) {
+            return {
+                portableFallback: "Tool payload exceeded the per-entry portable history limit.",
+                preview: redactSensitiveText(payload.previewText ?? row.preview_text ?? ""),
+            };
+        }
+        try {
+            return jsonValue(payload.contentType.includes("json")
+                ? this.store.payloads.readPayloadJson(row.payload_ref)
+                : this.store.payloads.readPayloadText(row.payload_ref));
+        }
+        catch {
+            return { portableFallback: "Tool payload could not be read from Pibo history." };
+        }
+    }
+    nonPortableEntryCount(piboSessionId, checkpoint) {
+        const row = this.store.db.prepare(`
+			SELECT COUNT(*) AS count
+			FROM event_log
+			WHERE session_id = ?
+				AND session_sequence <= ?
+				AND (type = 'pi_event' OR type LIKE 'thinking_%' OR type = 'subagent_session')
+		`).get(piboSessionId, checkpoint.maxSessionSequence);
+        return Number(row.count ?? 0);
+    }
+}
+function normalizeToolPairs(entries) {
+    const callIds = new Set();
+    const resultIds = new Set();
+    for (const entry of entries) {
+        if (entry.type !== "message")
+            continue;
+        if (entry.role === "tool" && entry.toolCallId)
+            resultIds.add(entry.toolCallId);
+        if (!Array.isArray(entry.content))
+            continue;
+        for (const part of entry.content) {
+            if (part.type === "tool_call")
+                callIds.add(part.toolCallId);
+        }
+    }
+    return entries.map((entry) => {
+        if (entry.type !== "message")
+            return entry;
+        if (entry.role === "tool" && entry.toolCallId && !callIds.has(entry.toolCallId)) {
+            return {
+                ...entry,
+                role: "user",
+                content: [
+                    `[Portable fallback: result from tool "${entry.toolName ?? "tool"}" had no retained matching call.]`,
+                    typeof entry.content === "string" ? entry.content : JSON.stringify(entry.result ?? null),
+                ].join("\n"),
+                toolCallId: undefined,
+                toolName: undefined,
+                result: undefined,
+                isError: undefined,
+            };
+        }
+        if (entry.role !== "assistant" || !Array.isArray(entry.content))
+            return entry;
+        const content = entry.content.map((part) => {
+            if (part.type !== "tool_call" || resultIds.has(part.toolCallId))
+                return part;
+            return {
+                type: "text",
+                text: `[Portable fallback: tool call "${part.toolName}" had no retained result.]\nInput: ${JSON.stringify(part.input ?? null)}`,
+            };
+        });
+        return content.some((part) => part.type === "tool_call")
+            ? { ...entry, content }
+            : { ...entry, content, toolCallId: undefined, toolName: undefined };
+    });
+}
+function boundEntries(entries, limits) {
+    const selected = [];
+    let bytes = 0;
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        const normalized = normalizeEntrySize(entry);
+        const size = entryBytes(normalized);
+        if (selected.length >= limits.maxEntries || bytes + size > limits.maxBytes)
+            continue;
+        selected.push(normalized);
+        bytes += size;
+    }
+    selected.reverse();
+    return { entries: selected, omittedEntries: entries.length - selected.length };
+}
+function normalizeEntrySize(entry) {
+    if (entry.type !== "message")
+        return entry;
+    if (typeof entry.content === "string")
+        return { ...entry, content: boundedText(entry.content) };
+    if (entryBytes(entry) <= MAX_ENTRY_BYTES)
+        return entry;
+    return {
+        ...entry,
+        content: boundedText(stringContent(entry)),
+        result: entry.result === undefined ? undefined : {
+            portableFallback: "Structured history content exceeded the per-entry limit.",
+        },
+    };
+}
+export function createPortableHistoryHandoffMetadata(input) {
+    return {
+        version: PORTABLE_HISTORY_VERSION,
+        status: "pending",
+        mode: input.mode,
+        sourceRuntimeInstanceId: input.sourceBinding.runtimeInstanceId,
+        sourceAdapterId: input.sourceBinding.adapterId,
+        targetRuntimeInstanceId: input.targetBinding.runtimeInstanceId,
+        targetAdapterId: input.targetBinding.adapterId,
+        requestedAt: new Date().toISOString(),
+        ...(input.checkpoint ? { checkpoint: { ...input.checkpoint } } : {}),
+    };
+}
+export function readPortableHistoryHandoffMetadata(metadata) {
+    const value = metadata?.[PORTABLE_HISTORY_HANDOFF_METADATA_KEY];
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (record.version !== PORTABLE_HISTORY_VERSION || record.status !== "pending" || (record.mode !== "import" && record.mode !== "fresh"))
+        return undefined;
+    if (!validBoundedIdentifier(record.sourceRuntimeInstanceId)
+        || !validBoundedIdentifier(record.sourceAdapterId)
+        || !validBoundedIdentifier(record.targetRuntimeInstanceId)
+        || !validBoundedIdentifier(record.targetAdapterId)
+        || !validTimestamp(record.requestedAt))
+        return undefined;
+    let checkpoint;
+    if (record.mode === "import") {
+        const raw = record.checkpoint;
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return undefined;
+        const selected = raw;
+        if (!Number.isSafeInteger(selected.maxSessionSequence) || Number(selected.maxSessionSequence) < 0 || !validTimestamp(selected.createdAt))
+            return undefined;
+        checkpoint = {
+            maxSessionSequence: Number(selected.maxSessionSequence),
+            createdAt: selected.createdAt,
+        };
+    }
+    return {
+        version: PORTABLE_HISTORY_VERSION,
+        status: "pending",
+        mode: record.mode,
+        sourceRuntimeInstanceId: record.sourceRuntimeInstanceId,
+        sourceAdapterId: record.sourceAdapterId,
+        targetRuntimeInstanceId: record.targetRuntimeInstanceId,
+        targetAdapterId: record.targetAdapterId,
+        requestedAt: record.requestedAt,
+        ...(checkpoint ? { checkpoint } : {}),
+    };
+}
+export function withPortableHistoryHandoffMetadata(metadata, handoff) {
+    return {
+        ...(metadata ?? {}),
+        [PORTABLE_HISTORY_HANDOFF_METADATA_KEY]: handoff,
+    };
+}
+export function withoutPortableHistoryHandoffMetadata(input) {
+    const { [PORTABLE_HISTORY_HANDOFF_METADATA_KEY]: _handoff, ...metadata } = input.metadata ?? {};
+    return {
+        ...metadata,
+        [PORTABLE_HISTORY_LAST_IMPORT_METADATA_KEY]: {
+            version: PORTABLE_HISTORY_VERSION,
+            status: "completed",
+            mode: input.handoff.mode,
+            sourceRuntimeInstanceId: input.handoff.sourceRuntimeInstanceId,
+            sourceAdapterId: input.handoff.sourceAdapterId,
+            targetRuntimeInstanceId: input.handoff.targetRuntimeInstanceId,
+            targetAdapterId: input.handoff.targetAdapterId,
+            requestedAt: input.handoff.requestedAt,
+            ...(input.handoff.checkpoint ? { checkpoint: { ...input.handoff.checkpoint } } : {}),
+            completedAt: new Date().toISOString(),
+            ...(input.history ? {
+                entryCount: input.history.entries.length,
+                truncated: input.history.truncated,
+                omittedEntries: input.history.omittedEntries,
+            } : {}),
+        },
+    };
+}