@otto-code/protocol 0.7.4 → 0.7.6

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

@@ -2,6 +2,7 @@ export type AgentAttentionReason = "finished" | "error" | "permission";
 export interface AgentAttentionNotificationData {
     [key: string]: unknown;
     serverId: string;
+    workspaceId?: string;
     agentId: string;
     reason: AgentAttentionReason;
 }
@@ -13,6 +14,7 @@ export interface AgentAttentionNotificationPayload {
 interface BuildAgentAttentionNotificationPayloadInput {
     reason: AgentAttentionReason;
     serverId: string;
+    workspaceId: string;
     agentId: string;
     assistantMessage?: string | null;
     permissionRequest?: NotificationPermissionRequest | null;

package/dist/agent-attention-notification.js

@@ -180,6 +180,7 @@ export function buildAgentAttentionNotificationPayload(input) {
         body,
         data: {
             serverId: input.serverId,
+            workspaceId: input.workspaceId,
             agentId: input.agentId,
             reason: input.reason,
         },

package/dist/agent-deep-link.d.ts

@@ -0,0 +1,8 @@
+export interface AgentDeepLinkTarget {
+    serverId: string;
+    agentId: string;
+}
+export declare function buildAgentDeepLinkRoute(target: AgentDeepLinkTarget): `/h/${string}/agent/${string}`;
+export declare function buildAgentDeepLink(target: AgentDeepLinkTarget): string;
+export declare function parseAgentDeepLink(input: string): AgentDeepLinkTarget | null;
+//# sourceMappingURL=agent-deep-link.d.ts.map

package/dist/agent-deep-link.js

@@ -0,0 +1,49 @@
+function normalizeSegment(value) {
+    return value.trim();
+}
+function normalizeAgentDeepLinkTarget(target) {
+    const serverId = normalizeSegment(target.serverId);
+    const agentId = normalizeSegment(target.agentId);
+    if (!serverId || !agentId) {
+        throw new Error("Agent deep links require a server ID and agent ID.");
+    }
+    return { serverId, agentId };
+}
+export function buildAgentDeepLinkRoute(target) {
+    const { serverId, agentId } = normalizeAgentDeepLinkTarget(target);
+    return `/h/${encodeURIComponent(serverId)}/agent/${encodeURIComponent(agentId)}`;
+}
+export function buildAgentDeepLink(target) {
+    return `otto:/${buildAgentDeepLinkRoute(target)}`;
+}
+export function parseAgentDeepLink(input) {
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== "otto:" ||
+        url.hostname !== "h" ||
+        url.username ||
+        url.password ||
+        url.port ||
+        url.search ||
+        url.hash) {
+        return null;
+    }
+    const segments = url.pathname.split("/").filter(Boolean);
+    if (segments.length !== 3 || segments[1] !== "agent") {
+        return null;
+    }
+    try {
+        const serverId = normalizeSegment(decodeURIComponent(segments[0] ?? ""));
+        const agentId = normalizeSegment(decodeURIComponent(segments[2] ?? ""));
+        return serverId && agentId ? { serverId, agentId } : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=agent-deep-link.js.map

package/dist/agent-types.d.ts

@@ -110,6 +110,7 @@ export interface ProviderSnapshotEntry {
     provider: AgentProvider;
     status: ProviderStatus;
     enabled: boolean;
+    source?: "builtin" | "custom";
     error?: string;
     models?: AgentModelDefinition[];
     modes?: AgentMode[];
@@ -373,6 +374,7 @@ export type AgentTimelineItem = {
     type: "user_message";
     text: string;
     messageId?: string;
+    clientMessageId?: string;
 } | {
     type: "assistant_message";
     text: string;
@@ -489,6 +491,18 @@ export interface ObservedSubagentUpdate {
     status: "initializing" | "running" | "idle" | "error" | "closed";
     requiresAttention?: boolean;
     usage?: AgentUsage;
+    /**
+     * True once this run is known to outlive an interrupt of the parent's turn —
+     * the provider backgrounded it, so the parent's teardown does not take it
+     * down. Sticky: the daemon keeps it set for the row's whole life, and
+     * propagates it to nested rows (a child of a backgrounded run survives too).
+     * Absent ⇒ foreground, i.e. the run dies with the turn that spawned it.
+     *
+     * Claude sets it for Workflow orchestration runs (always backgrounded) and
+     * for a Task/Agent whose tool_result turned out to be a launch ack rather
+     * than a final report. See docs/chat-lifecycle.md.
+     */
+    backgrounded?: boolean;
     /**
      * Tool invocations this subagent has made so far (cumulative). Neutral field
      * any provider can set; kept monotonic by the daemon so a status-only final

package/dist/binary-frames/file-transfer.d.ts

@@ -13,6 +13,7 @@ export declare const FileBeginMetadataSchema: z.ZodObject<{
         "utf-8": "utf-8";
     }>;
     modifiedAt: z.ZodString;
+    revision: z.ZodOptional<z.ZodString>;
     fileName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export interface FileBegin {

package/dist/binary-frames/file-transfer.js

@@ -10,6 +10,7 @@ export const FileBeginMetadataSchema = z.object({
     size: z.number().int().nonnegative(),
     encoding: z.enum(["utf-8", "binary"]),
     modifiedAt: z.string(),
+    revision: z.string().optional(),
     fileName: z.string().optional(),
 });
 export function encodeFileTransferFrame(input) {

package/dist/browser-automation/rpc-schemas.d.ts

@@ -489,6 +489,11 @@ export declare const BrowserAutomationTabInfoSchema: z.ZodObject<{
     isLoading: z.ZodDefault<z.ZodBoolean>;
     canGoBack: z.ZodOptional<z.ZodBoolean>;
     canGoForward: z.ZodOptional<z.ZodBoolean>;
+    status: z.ZodOptional<z.ZodEnum<{
+        ready: "ready";
+        starting: "starting";
+        detached: "detached";
+    }>>;
 }, z.core.$strip>;
 export declare const BrowserAutomationListTabsResultSchema: z.ZodObject<{
     command: z.ZodLiteral<"list_tabs">;
@@ -501,6 +506,11 @@ export declare const BrowserAutomationListTabsResultSchema: z.ZodObject<{
         isLoading: z.ZodDefault<z.ZodBoolean>;
         canGoBack: z.ZodOptional<z.ZodBoolean>;
         canGoForward: z.ZodOptional<z.ZodBoolean>;
+        status: z.ZodOptional<z.ZodEnum<{
+            ready: "ready";
+            starting: "starting";
+            detached: "detached";
+        }>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const BrowserAutomationNewTabResultSchema: z.ZodObject<{
@@ -783,6 +793,11 @@ export declare const BrowserAutomationResultSchema: z.ZodDiscriminatedUnion<[z.Z
         isLoading: z.ZodDefault<z.ZodBoolean>;
         canGoBack: z.ZodOptional<z.ZodBoolean>;
         canGoForward: z.ZodOptional<z.ZodBoolean>;
+        status: z.ZodOptional<z.ZodEnum<{
+            ready: "ready";
+            starting: "starting";
+            detached: "detached";
+        }>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     command: z.ZodLiteral<"new_tab">;
@@ -1250,6 +1265,11 @@ export declare const BrowserAutomationExecuteResponseSchema: z.ZodObject<{
                 isLoading: z.ZodDefault<z.ZodBoolean>;
                 canGoBack: z.ZodOptional<z.ZodBoolean>;
                 canGoForward: z.ZodOptional<z.ZodBoolean>;
+                status: z.ZodOptional<z.ZodEnum<{
+                    ready: "ready";
+                    starting: "starting";
+                    detached: "detached";
+                }>>;
             }, z.core.$strip>>;
         }, z.core.$strip>, z.ZodObject<{
             command: z.ZodLiteral<"new_tab">;
@@ -1518,6 +1538,7 @@ export type BrowserAutomationColorScheme = z.infer<typeof BrowserAutomationColor
 export type BrowserAutomationCommandName = z.infer<typeof BrowserAutomationCommandNameSchema>;
 export type BrowserAutomationCommand = z.infer<typeof BrowserAutomationCommandSchema>;
 export type BrowserAutomationResult = z.infer<typeof BrowserAutomationResultSchema>;
+export type BrowserAutomationTabInfo = z.infer<typeof BrowserAutomationTabInfoSchema>;
 export type BrowserAutomationConsoleLogEntry = z.infer<typeof BrowserAutomationConsoleLogEntrySchema>;
 export type BrowserAutomationNetworkLogEntry = z.infer<typeof BrowserAutomationNetworkLogEntrySchema>;
 export type BrowserAutomationNetworkRequestEntry = z.infer<typeof BrowserAutomationNetworkRequestEntrySchema>;

package/dist/browser-automation/rpc-schemas.js

@@ -306,6 +306,16 @@ export const BrowserAutomationTabInfoSchema = z.object({
     isLoading: z.boolean().default(false),
     canGoBack: z.boolean().optional(),
     canGoForward: z.boolean().optional(),
+    // Whether the tab's webview is attached and drivable. Reported explicitly so
+    // that "not drivable" is never expressed by leaving the tab OUT of the list:
+    // a tab the user can see on screen must always appear, or callers conclude it
+    // was closed and open a replacement. `starting` = registered, webview not
+    // attached yet; `detached` = it was attached and its contents are gone (a
+    // pane that stopped compositing looks like this). `url`/`title` are empty for
+    // both, because only the live webview knows them.
+    // COMPAT(browserTabStatus): added in v0.7.5; absent ⇒ "ready", which is how
+    // every pre-0.7.5 host behaved. Drop the gate when floor >= v0.7.5.
+    status: z.enum(["starting", "ready", "detached"]).optional(),
 });
 export const BrowserAutomationListTabsResultSchema = z.object({
     command: z.literal("list_tabs"),

package/dist/client-capabilities.d.ts

@@ -1,7 +1,10 @@
 export declare const CLIENT_CAPS: {
+    readonly selectiveAgentTimeline: "selective_agent_timeline";
     readonly reasoningMergeEnum: "reasoning_merge_enum";
     readonly customModeIcons: "custom_mode_icons";
     readonly terminalReflowableSnapshot: "terminal_reflowable_snapshot";
+    readonly providerSubagents: "provider_subagents";
+    readonly projectUpdates: "project_updates";
     readonly browserHost: "browser_host";
 };
 export type ClientCapability = (typeof CLIENT_CAPS)[keyof typeof CLIENT_CAPS];

package/dist/client-capabilities.js

@@ -1,4 +1,8 @@
 export const CLIENT_CAPS = {
+    // COMPAT(selectiveAgentTimeline): added in v0.1.106. Capable clients receive
+    // agent streams only for their explicit viewed set. Remove after 2027-01-12
+    // once the supported client floor is >= v0.1.106.
+    selectiveAgentTimeline: "selective_agent_timeline",
     reasoningMergeEnum: "reasoning_merge_enum",
     // COMPAT(customModeIcons): added in v0.1.84. Old clients pin AgentModeIcon to
     // a closed enum and crash rendering unknown values; daemon downgrades icons
@@ -11,6 +15,11 @@ export const CLIENT_CAPS = {
     // Old clients use a strict TerminalState schema and would reject the extra fields.
     // Drop the gate (always send the flags) when floor >= v0.1.88.
     terminalReflowableSnapshot: "terminal_reflowable_snapshot",
+    // COMPAT(providerSubagents): added in v0.1.107. The daemon emits provider-owned
+    // child descriptors and timelines only to clients that understand the new messages.
+    providerSubagents: "provider_subagents",
+    // COMPAT(projectUpdates): added in v0.1.109, remove gate after 2027-01-15.
+    projectUpdates: "project_updates",
     browserHost: "browser_host",
 };
 //# sourceMappingURL=client-capabilities.js.map

package/dist/forge-manifest.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Declarative manifest of the git forges Otto knows how to present, mirroring
+ * provider-manifest.ts. Pure build-time data shared by BOTH the client (icon,
+ * brand label, PR↔MR relabel) and the server (registry host-matching, prompt
+ * branding). It is NEVER serialized over the wire, so adding a forge here is not
+ * a protocol change.
+ *
+ * Keep this a pure leaf: no imports, no zod, no functions with runtime deps.
+ * Behavioural concerns (CLI invocation, host probing, REST adapters) live in the
+ * server adapter keyed by {@link ForgeDefinition.id}; this file is only the
+ * declarative half.
+ */
+/**
+ * Declarative sign-in recipe for a forge. The client renders install/sign-in
+ * hints from this data alone — no per-CLI switch — so a new forge wires its auth
+ * UX entirely from the manifest. Behavioural auth (the actual host probe) stays
+ * in the server adapter; this is only what the user is told to run.
+ */
+export interface ForgeSignInCommand {
+    /** Binary the user installs, e.g. "gh" — shown in the install-CLI hint. */
+    cli: string;
+    /** Full sign-in command, e.g. "gh auth login". */
+    command: string;
+    /**
+     * Flag that targets a self-hosted host, e.g. "--hostname". When present and a
+     * host is known, the client appends `${command} ${hostnameFlag} ${host}`.
+     * Omit when the command already targets the right host on its own.
+     */
+    hostnameFlag?: string;
+}
+export interface ForgeDefinition {
+    /** Registry id, matches the server adapter and the wire `forge` value. */
+    id: string;
+    /** Human brand name, e.g. for "Open on GitLab". */
+    displayName: string;
+    /** Short change-request noun: "PR" for GitHub, "MR" for GitLab. */
+    changeRequestAbbrev: string;
+    /** Full change-request noun: "pull request" vs "merge request". */
+    changeRequestNoun: string;
+    /** Prefix before a change-request number: "#" vs "!". */
+    changeRequestNumberPrefix: string;
+    /** Prefix before an issue number ("#" on every forge so far). */
+    issueNumberPrefix: string;
+    /** Icon key; the client falls back to a generic git icon for unknown values. */
+    iconKind: string;
+    /** Sign-in recipe, or null when the forge has no Otto-driven sign-in. */
+    signIn: ForgeSignInCommand | null;
+    /**
+     * Public cloud hosts this forge owns exactly. A BOUNDED list, never an
+     * allowlist for self-hosted detection — self-hosted/Enterprise instances are
+     * recognized at runtime by the adapter's host probe, not by this field.
+     */
+    cloudHosts?: string[];
+}
+export declare const FORGE_DEFINITIONS: ForgeDefinition[];
+/** Forge definitions only present in dev builds (none today; mirrors providers). */
+export declare const DEV_FORGE_DEFINITIONS: ForgeDefinition[];
+export declare const FORGE_IDS: string[];
+export declare function getForgeDefinition(id: string, definitions?: ForgeDefinition[]): ForgeDefinition | null;
+/**
+ * Resolve a forge definition, synthesizing a neutral one for a forge id the
+ * client has never heard of (e.g. a self-hosted forge a newer daemon reports to
+ * an older client). The neutral shape renders generic, never GitHub-branded.
+ */
+export declare function getForgeDefinitionOrNeutral(id: string): ForgeDefinition;
+//# sourceMappingURL=forge-manifest.d.ts.map

package/dist/forge-manifest.js

@@ -0,0 +1,92 @@
+/**
+ * Declarative manifest of the git forges Otto knows how to present, mirroring
+ * provider-manifest.ts. Pure build-time data shared by BOTH the client (icon,
+ * brand label, PR↔MR relabel) and the server (registry host-matching, prompt
+ * branding). It is NEVER serialized over the wire, so adding a forge here is not
+ * a protocol change.
+ *
+ * Keep this a pure leaf: no imports, no zod, no functions with runtime deps.
+ * Behavioural concerns (CLI invocation, host probing, REST adapters) live in the
+ * server adapter keyed by {@link ForgeDefinition.id}; this file is only the
+ * declarative half.
+ */
+export const FORGE_DEFINITIONS = [
+    {
+        id: "github",
+        displayName: "GitHub",
+        changeRequestAbbrev: "PR",
+        changeRequestNoun: "pull request",
+        changeRequestNumberPrefix: "#",
+        issueNumberPrefix: "#",
+        iconKind: "github",
+        signIn: { cli: "gh", command: "gh auth login" },
+        cloudHosts: ["github.com", "ssh.github.com"],
+    },
+    {
+        id: "gitlab",
+        displayName: "GitLab",
+        changeRequestAbbrev: "MR",
+        changeRequestNoun: "merge request",
+        changeRequestNumberPrefix: "!",
+        issueNumberPrefix: "#",
+        iconKind: "gitlab",
+        signIn: { cli: "glab", command: "glab auth login", hostnameFlag: "--hostname" },
+        cloudHosts: ["gitlab.com"],
+    },
+    {
+        id: "gitea",
+        displayName: "Gitea",
+        changeRequestAbbrev: "PR",
+        changeRequestNoun: "pull request",
+        changeRequestNumberPrefix: "#",
+        issueNumberPrefix: "#",
+        iconKind: "gitea",
+        signIn: { cli: "tea", command: "tea login add" },
+        cloudHosts: ["gitea.com"],
+    },
+    {
+        id: "forgejo",
+        displayName: "Forgejo",
+        changeRequestAbbrev: "PR",
+        changeRequestNoun: "pull request",
+        changeRequestNumberPrefix: "#",
+        issueNumberPrefix: "#",
+        iconKind: "forgejo",
+        signIn: { cli: "tea", command: "tea login add" },
+    },
+    {
+        id: "codeberg",
+        displayName: "Codeberg",
+        changeRequestAbbrev: "PR",
+        changeRequestNoun: "pull request",
+        changeRequestNumberPrefix: "#",
+        issueNumberPrefix: "#",
+        iconKind: "codeberg",
+        signIn: { cli: "tea", command: "tea login add" },
+        cloudHosts: ["codeberg.org"],
+    },
+];
+/** Forge definitions only present in dev builds (none today; mirrors providers). */
+export const DEV_FORGE_DEFINITIONS = [];
+export const FORGE_IDS = FORGE_DEFINITIONS.map((definition) => definition.id);
+export function getForgeDefinition(id, definitions = [...FORGE_DEFINITIONS, ...DEV_FORGE_DEFINITIONS]) {
+    return definitions.find((definition) => definition.id === id) ?? null;
+}
+/**
+ * Resolve a forge definition, synthesizing a neutral one for a forge id the
+ * client has never heard of (e.g. a self-hosted forge a newer daemon reports to
+ * an older client). The neutral shape renders generic, never GitHub-branded.
+ */
+export function getForgeDefinitionOrNeutral(id) {
+    return (getForgeDefinition(id) ?? {
+        id,
+        displayName: id,
+        changeRequestAbbrev: "PR",
+        changeRequestNoun: "pull request",
+        changeRequestNumberPrefix: "#",
+        issueNumberPrefix: "#",
+        iconKind: "git",
+        signIn: null,
+    });
+}
+//# sourceMappingURL=forge-manifest.js.map