@otto-code/protocol 0.5.0

package/README.md

@@ -0,0 +1,12 @@
+# @otto-code/protocol
+
+Shared Otto protocol schemas, codecs, and wire types.
+
+## Stability
+
+This package is public so Otto's published packages can depend on it cleanly.
+It is not a stable public API yet.
+
+Schemas, exports, wire helpers, and types may change or disappear in any release
+without advance notice. Use it outside Otto at your own risk until the package
+is explicitly documented as stable.

package/dist/agent-attention-notification.d.ts

@@ -0,0 +1,41 @@
+export type AgentAttentionReason = "finished" | "error" | "permission";
+export interface AgentAttentionNotificationData {
+    [key: string]: unknown;
+    serverId: string;
+    agentId: string;
+    reason: AgentAttentionReason;
+}
+export interface AgentAttentionNotificationPayload {
+    title: string;
+    body: string;
+    data: AgentAttentionNotificationData;
+}
+interface BuildAgentAttentionNotificationPayloadInput {
+    reason: AgentAttentionReason;
+    serverId: string;
+    agentId: string;
+    assistantMessage?: string | null;
+    permissionRequest?: NotificationPermissionRequest | null;
+}
+export interface NotificationPermissionRequest {
+    id: string;
+    provider: string;
+    name: string;
+    kind: "tool" | "plan" | "question" | "mode" | "other";
+    title?: string;
+    description?: string;
+    input?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export type AssistantTimelineItem = {
+    type: "assistant_message";
+    text: string;
+} | {
+    type: string;
+    text?: string;
+};
+export declare function findLatestAssistantMessageFromTimeline(timeline: readonly AssistantTimelineItem[]): string | null;
+export declare function findLatestPermissionRequest(pendingPermissions: ReadonlyMap<string, NotificationPermissionRequest>): NotificationPermissionRequest | null;
+export declare function buildAgentAttentionNotificationPayload(input: BuildAgentAttentionNotificationPayloadInput): AgentAttentionNotificationPayload;
+export {};
+//# sourceMappingURL=agent-attention-notification.d.ts.map

package/dist/agent-attention-notification.js

@@ -0,0 +1,140 @@
+const NOTIFICATION_PREVIEW_LIMIT = 220;
+const normalizeNotificationText = (text) => text.replace(/\s+/g, " ").trim();
+const truncateNotificationText = (text, limit) => {
+    if (text.length <= limit) {
+        return text;
+    }
+    const trimmed = text.slice(0, Math.max(0, limit - 3)).trimEnd();
+    return trimmed.length > 0 ? `${trimmed}...` : text.slice(0, limit);
+};
+const stripMarkdownToText = (markdown) => {
+    let text = markdown.replace(/\r\n/g, "\n");
+    // Strip fenced code markers but keep the code content itself.
+    text = text.replace(/^\s*```[^\n]*$/gm, "");
+    text = text.replace(/^\s*~~~[^\n]*$/gm, "");
+    // Markdown links/images.
+    text = text.replace(/!\[([^\]]*)\]\((?:[^()\\]|\\.)*\)/g, "$1");
+    text = text.replace(/\[([^\]]+)\]\((?:[^()\\]|\\.)*\)/g, "$1");
+    // Structural prefixes.
+    text = text.replace(/^\s{0,3}#{1,6}\s+/gm, "");
+    text = text.replace(/^\s{0,3}>+\s?/gm, "");
+    text = text.replace(/^\s{0,3}(?:[*+-]|\d+\.)\s+/gm, "");
+    text = text.replace(/^\s{0,3}(?:[-*_]\s*){3,}$/gm, "");
+    // Inline markdown markers.
+    text = text.replace(/`([^`]+)`/g, "$1");
+    text = text.replace(/\*\*([^*]+)\*\*/g, "$1");
+    text = text.replace(/__([^_]+)__/g, "$1");
+    text = text.replace(/\*([^*\n]+)\*/g, "$1");
+    text = text.replace(/_([^_\n]+)_/g, "$1");
+    text = text.replace(/~~([^~]+)~~/g, "$1");
+    // Angle-bracketed URL autolinks.
+    text = text.replace(/<([^>\n]+)>/g, "$1");
+    return text;
+};
+const buildNotificationPreview = (text) => {
+    if (!text) {
+        return null;
+    }
+    const normalized = normalizeNotificationText(stripMarkdownToText(text));
+    if (!normalized) {
+        return null;
+    }
+    return truncateNotificationText(normalized, NOTIFICATION_PREVIEW_LIMIT);
+};
+const safeStringify = (value) => {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return null;
+    }
+};
+const buildPermissionDetails = (request) => {
+    if (!request) {
+        return null;
+    }
+    const title = request.title?.trim();
+    const description = request.description?.trim();
+    const details = [];
+    if (title) {
+        details.push(title);
+    }
+    if (description && description !== title) {
+        details.push(description);
+    }
+    if (details.length > 0) {
+        return details.join(" - ");
+    }
+    const inputPreview = request.input ? safeStringify(request.input) : null;
+    if (inputPreview) {
+        return inputPreview;
+    }
+    const metadataPreview = request.metadata ? safeStringify(request.metadata) : null;
+    if (metadataPreview) {
+        return metadataPreview;
+    }
+    return request.name?.trim() || request.kind;
+};
+export function findLatestAssistantMessageFromTimeline(timeline) {
+    // Providers may stream assistant content in consecutive chunks.
+    const chunks = [];
+    for (let i = timeline.length - 1; i >= 0; i -= 1) {
+        const item = timeline[i];
+        if (item.type !== "assistant_message" || typeof item.text !== "string") {
+            if (chunks.length > 0) {
+                break;
+            }
+            continue;
+        }
+        chunks.push(item.text);
+    }
+    if (chunks.length === 0) {
+        return null;
+    }
+    return chunks.toReversed().join("");
+}
+export function findLatestPermissionRequest(pendingPermissions) {
+    let latest = null;
+    for (const request of pendingPermissions.values()) {
+        latest = request;
+    }
+    return latest;
+}
+function resolveAgentAttentionTitle(reason) {
+    if (reason === "permission")
+        return "Agent needs permission";
+    if (reason === "error")
+        return "Agent needs attention";
+    return "Agent finished";
+}
+function resolveAgentAttentionPreview(input) {
+    if (input.reason === "finished") {
+        return buildNotificationPreview(input.assistantMessage);
+    }
+    if (input.reason === "permission") {
+        return buildNotificationPreview(buildPermissionDetails(input.permissionRequest));
+    }
+    return null;
+}
+function resolveAgentAttentionFallbackBody(reason) {
+    if (reason === "permission")
+        return "Permission requested.";
+    if (reason === "error")
+        return "Encountered an error.";
+    return "Finished working.";
+}
+export function buildAgentAttentionNotificationPayload(input) {
+    const title = resolveAgentAttentionTitle(input.reason);
+    const preview = resolveAgentAttentionPreview(input);
+    const body = preview ?? resolveAgentAttentionFallbackBody(input.reason);
+    return {
+        title,
+        body,
+        data: {
+            serverId: input.serverId,
+            agentId: input.agentId,
+            reason: input.reason,
+        },
+    };
+}
+//# sourceMappingURL=agent-attention-notification.js.map

package/dist/agent-labels.d.ts

@@ -0,0 +1,7 @@
+export declare const PARENT_AGENT_ID_LABEL = "otto.parent-agent-id";
+export interface AgentLabelSource {
+    labels?: Record<string, unknown> | null;
+}
+export declare function getParentAgentIdFromLabels(labels: Record<string, unknown> | null | undefined): string | null;
+export declare function isDelegatedAgent(agent: AgentLabelSource): boolean;
+//# sourceMappingURL=agent-labels.d.ts.map

package/dist/agent-labels.js

@@ -0,0 +1,11 @@
+export const PARENT_AGENT_ID_LABEL = "otto.parent-agent-id";
+export function getParentAgentIdFromLabels(labels) {
+    const parentAgentId = labels?.[PARENT_AGENT_ID_LABEL];
+    return typeof parentAgentId === "string" && parentAgentId.trim().length > 0
+        ? parentAgentId.trim()
+        : null;
+}
+export function isDelegatedAgent(agent) {
+    return getParentAgentIdFromLabels(agent.labels) !== null;
+}
+//# sourceMappingURL=agent-labels.js.map

package/dist/agent-lifecycle.d.ts

@@ -0,0 +1,3 @@
+export declare const AGENT_LIFECYCLE_STATUSES: readonly ["initializing", "idle", "running", "error", "closed"];
+export type AgentLifecycleStatus = (typeof AGENT_LIFECYCLE_STATUSES)[number];
+//# sourceMappingURL=agent-lifecycle.d.ts.map

package/dist/agent-lifecycle.js

@@ -0,0 +1,8 @@
+export const AGENT_LIFECYCLE_STATUSES = [
+    "initializing",
+    "idle",
+    "running",
+    "error",
+    "closed",
+];
+//# sourceMappingURL=agent-lifecycle.js.map

package/dist/agent-personalities.d.ts

@@ -0,0 +1,32 @@
+import { type AgentPersonality, type PersonalityRole } from "./messages.js";
+export declare function isPersonalityRole(value: string): value is PersonalityRole;
+/**
+ * Filter an arbitrary role array (roles ride the wire as plain strings) down to
+ * the known set, deduped and returned in canonical `PERSONALITY_ROLES` order.
+ * Unknown roles from a newer peer are dropped rather than trusted.
+ */
+export declare function normalizePersonalityRoles(roles: readonly string[] | undefined): PersonalityRole[];
+export declare function personalityHasRole(personality: Pick<AgentPersonality, "roles">, role: PersonalityRole): boolean;
+export type PersonalityUnavailableCode = "provider-missing" | "provider-disabled" | "provider-not-ready" | "model-missing" | "mode-missing";
+export interface PersonalityAvailabilityInput {
+    /** Provider snapshot status, or undefined when the provider is absent entirely. */
+    providerStatus: "ready" | "loading" | "error" | "unavailable" | undefined;
+    providerEnabled: boolean | undefined;
+    modelIds: readonly string[] | undefined;
+    modeIds: readonly string[] | undefined;
+}
+export type PersonalityAvailability = {
+    available: true;
+} | {
+    available: false;
+    code: PersonalityUnavailableCode;
+    reason: string;
+};
+/**
+ * Decide whether a personality is usable against a provider's current snapshot.
+ * A personality is out of commission the moment any bound setting can't resolve:
+ * provider absent/disabled/not-ready, model gone, or an explicit mode missing.
+ * The caller grays it out in pickers and hard-fails it in automation.
+ */
+export declare function checkPersonalityAvailability(personality: Pick<AgentPersonality, "provider" | "model" | "modeId">, input: PersonalityAvailabilityInput): PersonalityAvailability;
+//# sourceMappingURL=agent-personalities.d.ts.map

package/dist/agent-personalities.js

@@ -0,0 +1,69 @@
+import { PERSONALITY_ROLES } from "./messages.js";
+// Pure, dependency-free personality helpers shared by the daemon (spawn-time
+// resolution) and the app (picker availability + role filtering). Effort
+// resolution is NOT here — it needs the model's advertised thinking options and
+// lives with the daemon's effort resolver; availability does not depend on it.
+const ROLE_SET = new Set(PERSONALITY_ROLES);
+export function isPersonalityRole(value) {
+    return ROLE_SET.has(value);
+}
+/**
+ * Filter an arbitrary role array (roles ride the wire as plain strings) down to
+ * the known set, deduped and returned in canonical `PERSONALITY_ROLES` order.
+ * Unknown roles from a newer peer are dropped rather than trusted.
+ */
+export function normalizePersonalityRoles(roles) {
+    if (!roles || roles.length === 0) {
+        return [];
+    }
+    const present = new Set(roles.filter(isPersonalityRole));
+    return PERSONALITY_ROLES.filter((role) => present.has(role));
+}
+export function personalityHasRole(personality, role) {
+    return normalizePersonalityRoles(personality.roles).includes(role);
+}
+/**
+ * Decide whether a personality is usable against a provider's current snapshot.
+ * A personality is out of commission the moment any bound setting can't resolve:
+ * provider absent/disabled/not-ready, model gone, or an explicit mode missing.
+ * The caller grays it out in pickers and hard-fails it in automation.
+ */
+export function checkPersonalityAvailability(personality, input) {
+    if (input.providerStatus === undefined) {
+        return {
+            available: false,
+            code: "provider-missing",
+            reason: `Provider "${personality.provider}" is not configured on this host.`,
+        };
+    }
+    if (input.providerEnabled === false) {
+        return {
+            available: false,
+            code: "provider-disabled",
+            reason: `Provider "${personality.provider}" is disabled.`,
+        };
+    }
+    if (input.providerStatus !== "ready") {
+        return {
+            available: false,
+            code: "provider-not-ready",
+            reason: `Provider "${personality.provider}" is not ready (${input.providerStatus}).`,
+        };
+    }
+    if (!(input.modelIds ?? []).includes(personality.model)) {
+        return {
+            available: false,
+            code: "model-missing",
+            reason: `Model "${personality.model}" is not available from "${personality.provider}".`,
+        };
+    }
+    if (personality.modeId !== undefined && !(input.modeIds ?? []).includes(personality.modeId)) {
+        return {
+            available: false,
+            code: "mode-missing",
+            reason: `Mode "${personality.modeId}" is not available from "${personality.provider}".`,
+        };
+    }
+    return { available: true };
+}
+//# sourceMappingURL=agent-personalities.js.map

package/dist/agent-state-bucket.d.ts

@@ -0,0 +1,14 @@
+import type { AgentLifecycleStatus } from "./agent-lifecycle.js";
+import type { WorkspaceStateBucket } from "./messages.js";
+export type { WorkspaceStateBucket };
+export type AgentAttentionReason = "finished" | "error" | "permission" | null | undefined;
+export interface AgentStateBucketInput {
+    status: AgentLifecycleStatus;
+    pendingPermissionCount?: number;
+    requiresAttention?: boolean;
+    attentionReason?: AgentAttentionReason;
+}
+export declare function deriveAgentStateBucket(input: AgentStateBucketInput): WorkspaceStateBucket;
+export declare function getWorkspaceStateBucketPriority(bucket: WorkspaceStateBucket): number;
+export declare function getAgentStatusPriority(input: AgentStateBucketInput): number;
+//# sourceMappingURL=agent-state-bucket.d.ts.map

package/dist/agent-state-bucket.js

@@ -0,0 +1,41 @@
+const WORKSPACE_STATE_BUCKET_PRIORITY = {
+    needs_input: 0,
+    failed: 1,
+    running: 2,
+    attention: 3,
+    done: 4,
+};
+export function deriveAgentStateBucket(input) {
+    if ((input.pendingPermissionCount ?? 0) > 0 || input.attentionReason === "permission") {
+        return "needs_input";
+    }
+    if (input.status === "error" || input.attentionReason === "error") {
+        return "failed";
+    }
+    if (input.status === "running") {
+        return "running";
+    }
+    if (input.requiresAttention) {
+        return "attention";
+    }
+    return "done";
+}
+export function getWorkspaceStateBucketPriority(bucket) {
+    return WORKSPACE_STATE_BUCKET_PRIORITY[bucket];
+}
+export function getAgentStatusPriority(input) {
+    if ((input.pendingPermissionCount ?? 0) > 0 || input.attentionReason === "permission") {
+        return 0;
+    }
+    if (input.status === "error" || input.attentionReason === "error") {
+        return 1;
+    }
+    if (input.status === "running") {
+        return 2;
+    }
+    if (input.status === "initializing") {
+        return 3;
+    }
+    return 4;
+}
+//# sourceMappingURL=agent-state-bucket.js.map

package/dist/agent-title-limits.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_EXPLICIT_AGENT_TITLE_CHARS = 200;
+//# sourceMappingURL=agent-title-limits.d.ts.map

package/dist/agent-title-limits.js

@@ -0,0 +1,2 @@
+export const MAX_EXPLICIT_AGENT_TITLE_CHARS = 200;
+//# sourceMappingURL=agent-title-limits.js.map