@otto-code/server 0.5.0

package/dist/server/server/agent/agent-personalities.d.ts

@@ -0,0 +1,59 @@
+import { type PersonalityUnavailableCode } from "@otto-code/protocol/agent-personalities";
+import type { AgentPersonality, AgentPersonalityVoice, PersonalityRole } from "@otto-code/protocol/messages";
+import type { ProviderSnapshotEntry } from "./agent-sdk-types.js";
+/**
+ * A personality resolved against a provider snapshot for one cwd — the concrete
+ * settings blob snapshotted onto an agent at spawn. Everything here is frozen at
+ * spawn time; later edits to the personality never mutate an already-spawned
+ * agent (see the lifecycle section of the charter).
+ */
+export interface ResolvedPersonalitySnapshot {
+    personalityId: string;
+    name: string;
+    provider: string;
+    model: string;
+    modeId?: string;
+    /** The provider/model-specific thinking option the canonical effort resolved to. */
+    thinkingOptionId?: string;
+    /** The canonical effort level the personality requested (e.g. "high"). */
+    effortLevel?: string;
+    effortMatch?: "exact-id" | "level" | "nearest";
+    /**
+     * True when the model could not honor the requested effort exactly — either
+     * the nearest option was substituted, or the model advertises options that
+     * don't map to the canonical scale. Callers surface this as a warning; it is
+     * NOT an availability failure.
+     */
+    effortDegraded: boolean;
+    /** The personality prompt, destined for the agent's systemPrompt. */
+    systemPrompt?: string;
+    /** When false, the personality prompt stands alone (no global append stacked). */
+    respectGlobalAppendPrompt: boolean;
+    spinner?: {
+        glowA: string;
+        glowB: string;
+    };
+    /**
+     * The TTS voice for this personality's spoken identity. A soft binding: it is
+     * carried through as-is and validated/fallen-back at playback time against the
+     * host's speech options, never gated here (the resolver has no TTS catalog).
+     */
+    voice?: AgentPersonalityVoice;
+    roles: PersonalityRole[];
+}
+export type PersonalityResolution = {
+    status: "available";
+    snapshot: ResolvedPersonalitySnapshot;
+} | {
+    status: "unavailable";
+    code: PersonalityUnavailableCode;
+    reason: string;
+};
+/**
+ * Resolve a personality to a concrete settings snapshot against the provider
+ * entries for a target cwd, or report why it is out of commission. Effort is
+ * mapped from the stored canonical level to the bound model's nearest advertised
+ * option here, at resolution time — never stored pre-resolved.
+ */
+export declare function resolvePersonality(personality: AgentPersonality, entries: readonly ProviderSnapshotEntry[]): PersonalityResolution;
+//# sourceMappingURL=agent-personalities.d.ts.map

package/dist/server/server/agent/agent-personalities.js

@@ -0,0 +1,103 @@
+import { checkPersonalityAvailability, normalizePersonalityRoles, } from "@otto-code/protocol/agent-personalities";
+import { resolveEffortOption } from "./effort-levels.js";
+/**
+ * Resolve a personality to a concrete settings snapshot against the provider
+ * entries for a target cwd, or report why it is out of commission. Effort is
+ * mapped from the stored canonical level to the bound model's nearest advertised
+ * option here, at resolution time — never stored pre-resolved.
+ */
+export function resolvePersonality(personality, entries) {
+    const entry = entries.find((candidate) => candidate.provider === personality.provider);
+    const model = entry?.models?.find((candidate) => candidate.id === personality.model);
+    const availability = checkPersonalityAvailability(personality, {
+        providerStatus: entry?.status,
+        providerEnabled: entry?.enabled,
+        modelIds: entry?.models?.map((candidate) => candidate.id),
+        modeIds: entry?.modes?.map((candidate) => candidate.id),
+    });
+    if (!availability.available) {
+        return { status: "unavailable", code: availability.code, reason: availability.reason };
+    }
+    if (!entry || !model) {
+        // Unreachable when availability passes (it already checked provider + model);
+        // keeps the function total and the types honest without a non-null assertion.
+        return {
+            status: "unavailable",
+            code: "model-missing",
+            reason: `Model "${personality.model}" is not available from "${personality.provider}".`,
+        };
+    }
+    const modeId = personality.modeId ?? resolveFallbackModeId(entry);
+    const effort = resolvePersonalityEffort(personality.effortLevel, model.thinkingOptions);
+    return { status: "available", snapshot: buildSnapshot(personality, modeId, effort) };
+}
+// The provider's defaultModeId can go stale relative to its modes catalog;
+// availability only validates the personality's own modeId, so an unvalidated
+// fallback would pass resolution and then throw inside setMode at apply time.
+function resolveFallbackModeId(entry) {
+    const fallback = entry.defaultModeId ?? undefined;
+    if (!fallback) {
+        return undefined;
+    }
+    if (entry.modes && entry.modes.length > 0 && !entry.modes.some((mode) => mode.id === fallback)) {
+        return undefined;
+    }
+    return fallback;
+}
+// Assemble the snapshot blob, omitting undefined optional fields so `toEqual`
+// comparisons and downstream JSON stay clean. Kept separate from
+// resolvePersonality so the per-field guards don't inflate that function's
+// cyclomatic complexity.
+function buildSnapshot(personality, modeId, effort) {
+    const snapshot = {
+        personalityId: personality.id,
+        name: personality.name,
+        provider: personality.provider,
+        model: personality.model,
+        effortDegraded: effort.degraded,
+        respectGlobalAppendPrompt: personality.respectGlobalAppendPrompt ?? true,
+        roles: normalizePersonalityRoles(personality.roles),
+    };
+    if (modeId !== undefined) {
+        snapshot.modeId = modeId;
+    }
+    if (effort.thinkingOptionId !== undefined) {
+        snapshot.thinkingOptionId = effort.thinkingOptionId;
+    }
+    if (personality.effortLevel !== undefined) {
+        snapshot.effortLevel = personality.effortLevel;
+    }
+    if (effort.matched !== undefined) {
+        snapshot.effortMatch = effort.matched;
+    }
+    if (personality.personalityPrompt !== undefined) {
+        snapshot.systemPrompt = personality.personalityPrompt;
+    }
+    if (personality.spinner !== undefined) {
+        snapshot.spinner = personality.spinner;
+    }
+    if (personality.voice !== undefined) {
+        snapshot.voice = personality.voice;
+    }
+    return snapshot;
+}
+function resolvePersonalityEffort(effortLevel, thinkingOptions) {
+    if (!effortLevel || !thinkingOptions || thinkingOptions.length === 0) {
+        return { degraded: false };
+    }
+    try {
+        const resolved = resolveEffortOption({ requested: effortLevel, thinkingOptions });
+        return {
+            thinkingOptionId: resolved.optionId,
+            matched: resolved.matched,
+            degraded: resolved.matched === "nearest",
+        };
+    }
+    catch {
+        // The model advertises thinking options but none map to the canonical scale
+        // (fully custom option ids). Leave effort unset rather than failing the
+        // personality — the agent still runs, just without a matched thinking level.
+        return { degraded: true };
+    }
+}
+//# sourceMappingURL=agent-personalities.js.map

package/dist/server/server/agent/agent-projections.d.ts

@@ -0,0 +1,35 @@
+import type { AgentListItemPayload, AgentSnapshotPayload, RecentProviderSessionDescriptorPayload } from "../messages.js";
+import type { StoredAgentRecord } from "./agent-storage.js";
+import type { AgentProvider, AgentRuntimeInfo, ImportableProviderSession, ObservedSubagentUpdate } from "./agent-sdk-types.js";
+import type { ManagedAgent } from "./agent-manager.js";
+export type { ManagedAgent };
+interface ProjectionOptions {
+    title?: string | null;
+    createdAt?: string;
+    internal?: boolean;
+}
+interface RecentProviderSessionProjectionOptions {
+    providerLabel: string;
+}
+export declare function resolveEffectiveThinkingOptionId(options: {
+    runtimeInfo?: AgentRuntimeInfo | null;
+    configuredThinkingOptionId?: string | null;
+}): string | null;
+export declare function toStoredAgentRecord(agent: ManagedAgent, options?: ProjectionOptions): StoredAgentRecord;
+export declare function toAgentPayload(agent: ManagedAgent, options?: ProjectionOptions): AgentSnapshotPayload;
+export declare function buildStoredAgentPayload(record: StoredAgentRecord, validProviders: Iterable<AgentProvider>): AgentSnapshotPayload;
+export declare function toObservedSubagentPayload(input: {
+    id: string;
+    parentAgentId: string;
+    provider: AgentProvider;
+    cwd: string;
+    workspaceId?: string;
+    createdAt: string;
+    update: ObservedSubagentUpdate;
+}): AgentSnapshotPayload;
+export declare function toAgentListItemPayload(agent: AgentSnapshotPayload): AgentListItemPayload;
+export declare function toRecentProviderSessionDescriptorPayload(session: ImportableProviderSession & {
+    provider: string;
+}, options: RecentProviderSessionProjectionOptions): RecentProviderSessionDescriptorPayload;
+export declare function resolveStoredAgentPayloadUpdatedAt(record: StoredAgentRecord): string;
+//# sourceMappingURL=agent-projections.d.ts.map

package/dist/server/server/agent/agent-projections.js

@@ -0,0 +1,488 @@
+import { PARENT_AGENT_ID_LABEL } from "@otto-code/protocol/agent-labels";
+import { isStoredAgentProviderAvailable, toAgentPersistenceHandle } from "../persistence-hooks.js";
+function normalizeThinkingOptionId(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : null;
+}
+function normalizeLabels(labels) {
+    if (!labels) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(labels).filter((entry) => typeof entry[1] === "string"));
+}
+export function resolveEffectiveThinkingOptionId(options) {
+    const runtimeInfo = options.runtimeInfo;
+    if (runtimeInfo && "thinkingOptionId" in runtimeInfo) {
+        return normalizeThinkingOptionId(runtimeInfo.thinkingOptionId);
+    }
+    return normalizeThinkingOptionId(options.configuredThinkingOptionId);
+}
+export function toStoredAgentRecord(agent, options) {
+    const createdAt = options?.createdAt ?? agent.createdAt.toISOString();
+    const config = buildSerializableConfig(agent.config);
+    const persistence = sanitizePersistenceHandle(agent.persistence);
+    const runtimeInfo = sanitizeRuntimeInfo(agent.runtimeInfo);
+    return {
+        id: agent.id,
+        provider: agent.provider,
+        cwd: agent.cwd,
+        workspaceId: agent.workspaceId,
+        createdAt,
+        updatedAt: agent.updatedAt.toISOString(),
+        lastActivityAt: agent.updatedAt.toISOString(),
+        lastUserMessageAt: agent.lastUserMessageAt ? agent.lastUserMessageAt.toISOString() : null,
+        title: options?.title ?? null,
+        labels: agent.labels,
+        lastStatus: agent.lifecycle,
+        lastModeId: agent.currentModeId ?? config?.modeId ?? null,
+        config: config ?? null,
+        runtimeInfo,
+        features: normalizeFeatures(agent.features),
+        persistence,
+        lastError: agent.lastError ?? undefined,
+        requiresAttention: agent.attention.requiresAttention,
+        attentionReason: agent.attention.requiresAttention ? agent.attention.attentionReason : null,
+        attentionTimestamp: agent.attention.requiresAttention
+            ? agent.attention.attentionTimestamp.toISOString()
+            : null,
+        internal: options?.internal,
+    };
+}
+export function toAgentPayload(agent, options) {
+    const runtimeInfo = sanitizeRuntimeInfo(agent.runtimeInfo);
+    const thinkingOptionId = agent.config.thinkingOptionId ?? null;
+    const effectiveThinkingOptionId = resolveEffectiveThinkingOptionId({
+        runtimeInfo,
+        configuredThinkingOptionId: thinkingOptionId,
+    });
+    const payload = {
+        id: agent.id,
+        provider: agent.provider,
+        cwd: agent.cwd,
+        ...(agent.workspaceId ? { workspaceId: agent.workspaceId } : {}),
+        model: agent.config.model ?? null,
+        thinkingOptionId,
+        effectiveThinkingOptionId,
+        ...(runtimeInfo ? { runtimeInfo } : {}),
+        createdAt: agent.createdAt.toISOString(),
+        updatedAt: agent.updatedAt.toISOString(),
+        lastUserMessageAt: agent.lastUserMessageAt ? agent.lastUserMessageAt.toISOString() : null,
+        status: agent.lifecycle,
+        capabilities: cloneCapabilities(agent.capabilities),
+        currentModeId: agent.currentModeId,
+        availableModes: cloneAvailableModes(agent.availableModes),
+        features: normalizeFeatures(agent.features),
+        pendingPermissions: sanitizePendingPermissions(agent.pendingPermissions),
+        persistence: sanitizePersistenceHandle(agent.persistence),
+        title: options?.title ?? null,
+        labels: agent.labels,
+        // Internal agents (e.g. artifact generation) have no client watching to
+        // approve/prompt them — render their tab read-only like an observed
+        // subagent. Other ManagedAgents stay attended; true observed subagents
+        // are produced by a separate projection (see observed-subagent-registry).
+        // See projects/observed-subagents/observed-subagents.md.
+        attend: agent.internal ? "observed" : "attended",
+    };
+    const usage = sanitizeUsage(agent.lastUsage);
+    if (usage !== undefined) {
+        payload.lastUsage = usage;
+    }
+    if (agent.lastError !== undefined) {
+        payload.lastError = agent.lastError;
+    }
+    const personalitySpinner = agent.config.personalitySnapshot?.spinner;
+    if (personalitySpinner !== undefined) {
+        payload.personalitySpinner = personalitySpinner;
+    }
+    const personalityName = agent.config.personalitySnapshot?.name;
+    if (personalityName !== undefined) {
+        payload.personalityName = personalityName;
+    }
+    const personalityId = agent.config.personalitySnapshot?.personalityId;
+    if (personalityId !== undefined) {
+        payload.personalityId = personalityId;
+    }
+    // Handle attention state
+    payload.requiresAttention = agent.attention.requiresAttention;
+    if (agent.attention.requiresAttention) {
+        payload.attentionReason = agent.attention.attentionReason;
+        payload.attentionTimestamp = agent.attention.attentionTimestamp.toISOString();
+    }
+    else {
+        payload.attentionReason = null;
+        payload.attentionTimestamp = null;
+    }
+    return payload;
+}
+function buildStoredRuntimeInfo(record) {
+    if (!record.runtimeInfo)
+        return undefined;
+    const ri = record.runtimeInfo;
+    const runtimeInfo = {
+        provider: ri.provider,
+        sessionId: ri.sessionId,
+    };
+    if (Object.prototype.hasOwnProperty.call(ri, "model")) {
+        runtimeInfo.model = ri.model ?? null;
+    }
+    if (Object.prototype.hasOwnProperty.call(ri, "thinkingOptionId")) {
+        runtimeInfo.thinkingOptionId = ri.thinkingOptionId ?? null;
+    }
+    if (Object.prototype.hasOwnProperty.call(ri, "modeId")) {
+        runtimeInfo.modeId = ri.modeId ?? null;
+    }
+    if (ri.extra) {
+        runtimeInfo.extra = ri.extra;
+    }
+    return runtimeInfo;
+}
+function buildStoredPersistenceHandle(record, validProviders) {
+    if (!isStoredAgentProviderAvailable(record, validProviders)) {
+        return null;
+    }
+    return toAgentPersistenceHandle(validProviders, record.persistence);
+}
+export function buildStoredAgentPayload(record, validProviders) {
+    const defaultCapabilities = {
+        supportsStreaming: false,
+        supportsSessionPersistence: true,
+        supportsDynamicModes: false,
+        supportsMcpServers: false,
+        supportsReasoningStream: false,
+        supportsToolInvocations: true,
+        supportsRewindConversation: false,
+        supportsRewindFiles: false,
+        supportsRewindBoth: false,
+    };
+    const createdAt = new Date(record.createdAt);
+    const updatedAt = new Date(resolveStoredAgentPayloadUpdatedAt(record));
+    const lastUserMessageAt = record.lastUserMessageAt ? new Date(record.lastUserMessageAt) : null;
+    const runtimeInfo = buildStoredRuntimeInfo(record);
+    const providerAvailable = isStoredAgentProviderAvailable(record, validProviders);
+    const persistence = buildStoredPersistenceHandle(record, validProviders);
+    return {
+        id: record.id,
+        provider: record.provider,
+        cwd: record.cwd,
+        ...(record.workspaceId ? { workspaceId: record.workspaceId } : {}),
+        model: record.config?.model ?? null,
+        thinkingOptionId: record.config?.thinkingOptionId ?? null,
+        effectiveThinkingOptionId: resolveEffectiveThinkingOptionId({
+            runtimeInfo,
+            configuredThinkingOptionId: record.config?.thinkingOptionId ?? null,
+        }),
+        ...(runtimeInfo ? { runtimeInfo } : {}),
+        createdAt: createdAt.toISOString(),
+        updatedAt: updatedAt.toISOString(),
+        lastUserMessageAt: lastUserMessageAt ? lastUserMessageAt.toISOString() : null,
+        status: record.lastStatus,
+        capabilities: defaultCapabilities,
+        currentModeId: record.lastModeId ?? null,
+        availableModes: [],
+        pendingPermissions: [],
+        persistence,
+        title: record.title ?? null,
+        requiresAttention: record.requiresAttention ?? false,
+        attentionReason: record.attentionReason ?? null,
+        attentionTimestamp: record.attentionTimestamp ?? null,
+        archivedAt: record.archivedAt ?? null,
+        labels: normalizeLabels(record.labels),
+        attend: "attended",
+        ...buildStoredAgentPayloadTail(record, providerAvailable),
+    };
+}
+// Optional payload fields for a stored agent, factored out to keep
+// buildStoredAgentPayload under the complexity budget.
+function buildStoredAgentPayloadTail(record, providerAvailable) {
+    const tail = {};
+    const spinner = record.config?.personalitySnapshot?.spinner;
+    if (spinner) {
+        tail.personalitySpinner = spinner;
+    }
+    const personalityName = record.config?.personalitySnapshot?.name;
+    if (personalityName) {
+        tail.personalityName = personalityName;
+    }
+    const personalityId = record.config?.personalitySnapshot?.personalityId;
+    if (personalityId) {
+        tail.personalityId = personalityId;
+    }
+    if (!providerAvailable) {
+        tail.providerUnavailable = true;
+    }
+    return tail;
+}
+// Observed subagents have no Otto runtime — all interactive capabilities are
+// false so the client hides model/mode/thinking/rewind controls, leaving a
+// read-only pane. Tool invocations stay true so the transcript renders tool
+// calls. See projects/observed-subagents/observed-subagents.md.
+const OBSERVED_SUBAGENT_CAPABILITIES = {
+    supportsStreaming: false,
+    supportsSessionPersistence: false,
+    supportsDynamicModes: false,
+    supportsMcpServers: false,
+    supportsReasoningStream: false,
+    supportsToolInvocations: true,
+    supportsRewindConversation: false,
+    supportsRewindFiles: false,
+    supportsRewindBoth: false,
+};
+export function toObservedSubagentPayload(input) {
+    const { update } = input;
+    const title = update.description ?? update.subAgentType ?? "Subagent";
+    const nowIso = new Date().toISOString();
+    const isError = update.status === "error";
+    const requiresAttention = update.requiresAttention ?? isError;
+    let attentionReason = null;
+    if (requiresAttention) {
+        attentionReason = isError ? "error" : "finished";
+    }
+    const payload = {
+        id: input.id,
+        provider: input.provider,
+        cwd: input.cwd,
+        ...(input.workspaceId ? { workspaceId: input.workspaceId } : {}),
+        model: null,
+        thinkingOptionId: null,
+        effectiveThinkingOptionId: null,
+        createdAt: input.createdAt,
+        updatedAt: nowIso,
+        lastUserMessageAt: null,
+        status: update.status,
+        capabilities: { ...OBSERVED_SUBAGENT_CAPABILITIES },
+        currentModeId: null,
+        availableModes: [],
+        pendingPermissions: [],
+        persistence: null,
+        title,
+        labels: { [PARENT_AGENT_ID_LABEL]: input.parentAgentId },
+        attend: "observed",
+        requiresAttention,
+        attentionReason,
+        attentionTimestamp: requiresAttention ? nowIso : null,
+    };
+    const usage = sanitizeUsage(update.usage);
+    if (usage !== undefined) {
+        payload.lastUsage = usage;
+    }
+    return payload;
+}
+export function toAgentListItemPayload(agent) {
+    return {
+        id: agent.id,
+        shortId: agent.id.slice(0, 7),
+        title: agent.title,
+        provider: agent.provider,
+        model: agent.runtimeInfo?.model ?? agent.model,
+        thinkingOptionId: agent.thinkingOptionId,
+        effectiveThinkingOptionId: agent.effectiveThinkingOptionId,
+        status: agent.status,
+        cwd: agent.cwd,
+        createdAt: agent.createdAt,
+        updatedAt: agent.updatedAt,
+        lastUserMessageAt: agent.lastUserMessageAt,
+        archivedAt: agent.archivedAt ?? null,
+        requiresAttention: agent.requiresAttention ?? false,
+        attentionReason: agent.attentionReason ?? null,
+        attentionTimestamp: agent.attentionTimestamp ?? null,
+        labels: agent.labels,
+        ...(agent.providerUnavailable ? { providerUnavailable: true } : {}),
+    };
+}
+export function toRecentProviderSessionDescriptorPayload(session, options) {
+    return {
+        providerId: session.provider,
+        providerLabel: options.providerLabel,
+        providerHandleId: session.providerHandleId,
+        cwd: session.cwd,
+        title: session.title,
+        firstPromptPreview: session.firstPromptPreview,
+        lastPromptPreview: session.lastPromptPreview,
+        lastActivityAt: session.lastActivityAt.toISOString(),
+    };
+}
+export function resolveStoredAgentPayloadUpdatedAt(record) {
+    const timestamps = [record.updatedAt, record.lastActivityAt]
+        .filter((value) => typeof value === "string" && value.length > 0)
+        .map((value) => ({
+        raw: value,
+        parsed: Date.parse(value),
+    }))
+        .filter((value) => !Number.isNaN(value.parsed));
+    if (timestamps.length === 0) {
+        return record.updatedAt;
+    }
+    timestamps.sort((a, b) => b.parsed - a.parsed);
+    return timestamps[0].raw;
+}
+function buildSerializableConfig(config) {
+    const serializable = {};
+    if (config.modeId) {
+        serializable.modeId = config.modeId;
+    }
+    if (config.model) {
+        serializable.model = config.model;
+    }
+    if (config.thinkingOptionId) {
+        serializable.thinkingOptionId = config.thinkingOptionId;
+    }
+    if (Object.prototype.hasOwnProperty.call(config, "featureValues")) {
+        const featureValues = sanitizeMetadata(config.featureValues);
+        if (featureValues !== undefined) {
+            serializable.featureValues = featureValues;
+        }
+    }
+    const extra = sanitizeMetadata(config.extra);
+    if (extra !== undefined) {
+        serializable.extra = extra;
+    }
+    if (config.systemPrompt) {
+        serializable.systemPrompt = config.systemPrompt;
+    }
+    if (config.mcpServers) {
+        serializable.mcpServers = config.mcpServers;
+    }
+    if (config.personalitySnapshot) {
+        serializable.personalitySnapshot = config.personalitySnapshot;
+    }
+    return Object.keys(serializable).length ? serializable : null;
+}
+function sanitizePendingPermissions(pending) {
+    return Array.from(pending.values()).map((request) => Object.assign({}, request, {
+        input: sanitizeMetadata(request.input),
+        suggestions: sanitizeMetadataArray(request.suggestions),
+        actions: request.actions?.map((action) => Object.assign({}, action)),
+        metadata: sanitizeMetadata(request.metadata),
+    }));
+}
+function sanitizePersistenceHandle(handle) {
+    if (!handle) {
+        return null;
+    }
+    const sanitized = {
+        provider: handle.provider,
+        sessionId: handle.sessionId,
+    };
+    if (handle.nativeHandle !== undefined) {
+        sanitized.nativeHandle = handle.nativeHandle;
+    }
+    const metadata = sanitizeMetadata(handle.metadata);
+    if (metadata !== undefined) {
+        sanitized.metadata = metadata;
+    }
+    return sanitized;
+}
+function cloneCapabilities(capabilities) {
+    return { ...capabilities };
+}
+function cloneAvailableModes(modes) {
+    return modes.map((mode) => ({ ...mode }));
+}
+function normalizeFeatures(features) {
+    return Array.isArray(features) ? features.map((feature) => ({ ...feature })) : [];
+}
+function sanitizeOptionalJson(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        const sanitized = value
+            .map((item) => sanitizeOptionalJson(item))
+            .filter((item) => item !== undefined);
+        return sanitized;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === "object") {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            const sanitized = sanitizeOptionalJson(val);
+            if (sanitized !== undefined) {
+                result[key] = sanitized;
+            }
+        }
+        return Object.keys(result).length ? result : undefined;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    return undefined;
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sanitizeMetadata(value) {
+    const sanitized = sanitizeOptionalJson(value);
+    if (!sanitized || !isJsonObject(sanitized)) {
+        return undefined;
+    }
+    return sanitized;
+}
+function sanitizeMetadataArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const sanitized = value
+        .map((entry) => sanitizeMetadata(entry))
+        .filter((entry) => entry !== undefined);
+    return sanitized.length > 0 ? sanitized : undefined;
+}
+function assignFiniteNumber(source, target, field) {
+    const raw = source[field];
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+        target[field] = raw;
+        return true;
+    }
+    return raw === undefined || raw === null;
+}
+function sanitizeUsage(value) {
+    const sanitized = sanitizeOptionalJson(value);
+    if (!sanitized || !isJsonObject(sanitized)) {
+        return undefined;
+    }
+    const result = {};
+    const fields = [
+        "inputTokens",
+        "cachedInputTokens",
+        "outputTokens",
+        "totalCostUsd",
+        "contextWindowMaxTokens",
+        "contextWindowUsedTokens",
+    ];
+    for (const field of fields) {
+        if (!assignFiniteNumber(sanitized, result, field)) {
+            return undefined;
+        }
+    }
+    return Object.keys(result).length ? result : undefined;
+}
+function sanitizeRuntimeInfo(runtimeInfo) {
+    if (!runtimeInfo) {
+        return undefined;
+    }
+    const sanitized = {
+        provider: runtimeInfo.provider,
+        sessionId: runtimeInfo.sessionId,
+    };
+    if (runtimeInfo.model !== undefined) {
+        sanitized.model = runtimeInfo.model;
+    }
+    if (runtimeInfo.thinkingOptionId !== undefined) {
+        sanitized.thinkingOptionId = runtimeInfo.thinkingOptionId;
+    }
+    if (runtimeInfo.modeId !== undefined) {
+        sanitized.modeId = runtimeInfo.modeId;
+    }
+    const extra = sanitizeMetadata(runtimeInfo.extra);
+    if (extra !== undefined) {
+        sanitized.extra = extra;
+    }
+    return sanitized;
+}
+//# sourceMappingURL=agent-projections.js.map