@linkshell/wire 0.2.8 → 0.2.9

package/src/rpc.ts

@@ -1,7 +1,10 @@
 import { z } from "zod";
 import { goalChangeSchema, sessionGoalSchema } from "./goal.js";
+import { acpAgentSettingsSchema, acpFeaturesSchema, acpRemoteAgentSchema, acpProviderSchema } from "./acp.js";
+import { editorRequestSchema, editorResultSchema } from "./editor.js";
 import {
   backgroundTaskSchema,
+  agentInfoSchema,
   gatewayStatusSchema,
   machineInfoSchema,
   portInfoSchema,
@@ -13,8 +16,9 @@ import {
   gitInfoSchema,
   worktreeEntrySchema,
   questionAnswerSchema,
+  pendingPermissionSchema,
 } from "./model.js";
-import { contentBlockSchema, sessionEventSchema } from "./updates.js";
+import { contentBlockSchema, sessionEventSchema, sessionNoticeSchema } from "./updates.js";
 
 // ── JSON-RPC 2.0 framing ─────────────────────────────────────────────
 
@@ -72,7 +76,36 @@ export const directoryEntrySchema = z.object({
 });
 export type DirectoryEntry = z.infer<typeof directoryEntrySchema>;
 
-export const methods = {
+const acpMethods = {
+  "agents.editor": { params: editorRequestSchema, result: editorResultSchema },
+  "agents.acp": {
+    params: z.object({ agent: z.string().min(1), sessionId: z.string().optional() }),
+    result: z.object({ features: acpFeaturesSchema, settings: acpAgentSettingsSchema, interactions: z.array(pendingPermissionSchema) }),
+  },
+  "agents.pending": { params: empty, result: z.object({ interactions: z.array(z.object({ agent: z.string(), request: pendingPermissionSchema })) }) },
+  "agents.configure": {
+    params: z.object({ agent: z.string().min(1), settings: acpAgentSettingsSchema, sessionId: z.string().optional() }),
+    result: empty,
+  },
+  "agents.authenticate": {
+    params: z.object({ agent: z.string().min(1), methodId: z.string().optional(), logout: z.boolean().optional() }),
+    result: z.object({ terminalId: z.string().optional() }),
+  },
+  "agents.respond": {
+    params: z.object({ agent: z.string().min(1), requestId: z.string().min(1), optionId: z.string().optional(), answers: z.array(questionAnswerSchema).optional() }),
+    result: empty,
+  },
+  "agents.providers": {
+    params: z.object({ agent: z.string().min(1), operation: z.enum(["list", "set", "disable"]), config: z.object({ providerId: z.string(), apiType: z.string().optional(), baseUrl: z.string().url().optional(), headers: z.record(z.string()).optional() }).optional() }),
+    result: z.object({ providers: z.array(acpProviderSchema) }),
+  },
+  "agents.custom": {
+    params: z.object({ save: acpRemoteAgentSchema.optional(), remove: z.string().optional() }),
+    result: z.object({ agents: z.array(acpRemoteAgentSchema) }),
+  },
+} as const;
+
+const coreMethods = {
   "machine.info": {
     params: empty,
     result: machineInfoSchema,
@@ -152,6 +185,10 @@ export const methods = {
     params: z.object({ sessionId: z.string().min(1) }),
     result: z.object({ subagents: z.array(subagentInfoSchema) }),
   },
+  "sessions.cancelSubagent": {
+    params: z.object({ sessionId: z.string().min(1), nativeSessionId: z.string().min(1) }),
+    result: empty,
+  },
   /**
    * One sub-agent's conversation: the call that started it and the events
    * under it (the latest 2000), oldest first. Later ones arrive on the
@@ -575,6 +612,8 @@ export const methods = {
   },
 } as const;
 
+export const methods: typeof coreMethods & typeof acpMethods = { ...coreMethods, ...acpMethods };
+
 export type MethodName = keyof typeof methods;
 export type MethodParams<M extends MethodName> = z.input<(typeof methods)[M]["params"]>;
 export type MethodResult<M extends MethodName> = z.infer<(typeof methods)[M]["result"]>;
@@ -586,6 +625,9 @@ export function isMethodName(name: string): name is MethodName {
 // ── Notifications (host → client) ────────────────────────────────────
 
 export const notifications = {
+  "agent.changed": z.object({ agent: agentInfoSchema }),
+  "agent.interaction": z.object({ agent: z.string(), request: z.union([pendingPermissionSchema, z.object({ requestId: z.string(), resolved: z.literal(true) })]) }),
+  "session.notice": z.object({ sessionId: z.string(), notice: sessionNoticeSchema }),
   "session.event": sessionEventSchema,
   /**
    * Sent before a subscription's backlog when it doesn't continue from the

package/src/updates.ts

@@ -2,54 +2,14 @@ import { z } from "zod";
 import { asyncQuestionSchema } from "./async-questions.js";
 import { sessionGoalSchema } from "./goal.js";
 import { backgroundTaskSchema, permissionOptionSchema, questionAnswerSchema, questionSchema, sessionDriverSchema, sessionStateSchema, toolKindSchema } from "./model.js";
+import { contentBlockSchema, toolCallContentSchema, toolCallStatusSchema } from "./content.js";
+export * from "./content.js";
 import { workflowAgentStateSchema, workflowSchema } from "./workflow.js";
 
 // Session updates mirror ACP's `SessionUpdate` shapes (discriminated by
 // `sessionUpdate`) so one renderer works for every agent. LinkShell-specific
 // updates use the `ls_` prefix.
 
-export const contentBlockSchema = z.discriminatedUnion("type", [
-  z.object({ type: z.literal("text"), text: z.string() }),
-  z.object({
-    type: z.literal("image"),
-    mimeType: z.string(),
-    data: z.string().optional(),
-    uri: z.string().optional(),
-  }),
-  z.object({
-    type: z.literal("resource_link"),
-    uri: z.string(),
-    name: z.string(),
-    /** What the link names: a file (default), a skill the user invoked, or another agent. */
-    kind: z.enum(["file", "skill", "agent"]).optional(),
-  }),
-]);
-export type ContentBlock = z.infer<typeof contentBlockSchema>;
-
-export const toolCallStatusSchema = z.enum(["pending", "in_progress", "completed", "failed"]);
-export type ToolCallStatus = z.infer<typeof toolCallStatusSchema>;
-
-export const toolCallContentSchema = z.discriminatedUnion("type", [
-  z.object({ type: z.literal("content"), content: contentBlockSchema }),
-  /** ACP diff: full before/after text. */
-  z.object({
-    type: z.literal("diff"),
-    path: z.string(),
-    oldText: z.string().nullable().optional(),
-    newText: z.string(),
-  }),
-  /** Unified diff, for agents (Codex) that report patches rather than file text. */
-  z.object({
-    type: z.literal("patch"),
-    path: z.string(),
-    change: z.enum(["add", "delete", "update"]),
-    movePath: z.string().optional(),
-    diff: z.string(),
-  }),
-  z.object({ type: z.literal("terminal"), terminalId: z.string() }),
-]);
-export type ToolCallContent = z.infer<typeof toolCallContentSchema>;
-
 export const toolCallLocationSchema = z.object({
   path: z.string(),
   line: z.number().int().optional(),
@@ -72,6 +32,8 @@ export const toolDetailSchema = z.discriminatedUnion("type", [
     agentType: z.string().optional(),
     /** A named agent's address, distinct from its role. */
     name: z.string().optional(),
+    nativeSessionId: z.string().optional(),
+    canCancel: z.boolean().optional(),
     model: z.string().optional(),
     /** Agent outcome when a tool's coarse completed/failed state is insufficient. */
     state: workflowAgentStateSchema.optional(),
@@ -95,20 +57,30 @@ export const planEntrySchema = z.object({
 });
 export type PlanEntry = z.infer<typeof planEntrySchema>;
 
-export const stopReasonSchema = z.enum(["end_turn", "cancelled", "error", "max_tokens", "refusal"]);
+export const stopReasonSchema = z.enum(["end_turn", "cancelled", "error", "max_tokens", "max_turn_requests", "refusal", "unknown"]);
 export type StopReason = z.infer<typeof stopReasonSchema>;
 
 export const sessionConfigOptionSchema = z.object({
   /** Agent-defined id; "model" and "mode" are the common ones. */
   id: z.string(),
   name: z.string(),
-  category: z.enum(["model", "mode", "effort", "other"]).default("other"),
+  description: z.string().optional(),
+  type: z.enum(["select", "boolean"]).optional(),
+  category: z.enum(["model", "model_config", "mode", "effort", "other"]).default("other"),
   current: z.string(),
-  values: z.array(z.object({ value: z.string(), name: z.string(), description: z.string().optional() })),
+  values: z.array(z.object({ value: z.string(), name: z.string(), description: z.string().optional(), group: z.string().optional() })),
 });
 export type SessionConfigOption = z.infer<typeof sessionConfigOptionSchema>;
 
 export const sessionUpdateSchema = z.discriminatedUnion("sessionUpdate", [
+  z.object({
+    sessionUpdate: z.literal("ls_message"),
+    messageId: z.string(), role: z.enum(["user", "agent", "thought", "session"]),
+    parentToolCallId: z.string().optional(),
+    content: z.array(contentBlockSchema).optional(),
+    append: z.boolean().optional(),
+    senderSessionId: z.string().optional(), recipientSessionId: z.string().optional(),
+  }),
   z.object({
     sessionUpdate: z.literal("user_message_chunk"),
     messageId: z.string().optional(),
@@ -132,9 +104,11 @@ export const sessionUpdateSchema = z.discriminatedUnion("sessionUpdate", [
     /** Set when a sub-agent made this call: the sub-agent's own (spawn) tool call. */
     parentToolCallId: z.string().optional(),
     title: z.string(),
+    name: z.string().optional(),
     kind: toolKindSchema,
     status: toolCallStatusSchema,
     rawInput: z.unknown().optional(),
+    rawOutput: z.unknown().optional(),
     content: z.array(toolCallContentSchema).optional(),
     locations: z.array(toolCallLocationSchema).optional(),
     detail: toolDetailSchema.optional(),
@@ -145,16 +119,28 @@ export const sessionUpdateSchema = z.discriminatedUnion("sessionUpdate", [
     parentToolCallId: z.string().optional(),
     status: toolCallStatusSchema.optional(),
     title: z.string().optional(),
+    name: z.string().optional(),
+    kind: toolKindSchema.optional(),
+    rawInput: z.unknown().optional(),
+    locations: z.array(toolCallLocationSchema).optional(),
     detail: toolDetailSchema.optional(),
     /** Replaces the tool call's content when present. */
     content: z.array(toolCallContentSchema).optional(),
     /** Streamed output appended to the tool call's running output. */
     appendOutput: z.string().optional(),
+    replaceOutput: z.string().optional(),
+    /** ACP v2 null/empty content clears every previous diff and attachment. */
+    replaceContent: z.boolean().optional(),
     rawOutput: z.unknown().optional(),
   }),
   z.object({
     sessionUpdate: z.literal("plan"),
     entries: z.array(planEntrySchema),
+    planId: z.string().optional(),
+    title: z.string().optional(),
+    markdown: z.string().nullable().optional(),
+    path: z.string().nullable().optional(),
+    removed: z.boolean().optional(),
   }),
   z.object({
     sessionUpdate: z.literal("ls_goal"),
@@ -172,13 +158,16 @@ export const sessionUpdateSchema = z.discriminatedUnion("sessionUpdate", [
   }),
   z.object({
     sessionUpdate: z.literal("session_info_update"),
-    title: z.string().optional(),
+    title: z.string().nullable().optional(),
+    updatedAt: z.string().nullable().optional(),
     model: z.string().optional(),
   }),
   z.object({
     sessionUpdate: z.literal("usage_update"),
     usedTokens: z.number().optional(),
     contextWindow: z.number().optional(),
+    cost: z.object({ amount: z.number(), currency: z.string() }).nullable().optional(),
+    tokens: z.object({ totalTokens: z.number(), inputTokens: z.number(), outputTokens: z.number(), thoughtTokens: z.number().nullish(), cachedReadTokens: z.number().nullish(), cachedWriteTokens: z.number().nullish() }).optional(),
   }),
   // ── LinkShell extensions ──
   z.object({
@@ -219,9 +208,13 @@ export const sessionUpdateSchema = z.discriminatedUnion("sessionUpdate", [
   z.object({
     sessionUpdate: z.literal("ls_permission"),
     requestId: z.string(),
+    childSessionId: z.string().optional(),
     toolCallId: z.string().optional(),
     title: z.string(),
     detail: z.string().optional(),
+    tool: z.object({ title: z.string().optional(), kind: toolKindSchema.optional(), rawInput: z.unknown().optional(), content: z.array(toolCallContentSchema).optional(), locations: z.array(toolCallLocationSchema).optional() }).optional(),
+    /** URL interactions stay out of form answers and are opened only after consent. */
+    url: z.object({ url: z.string(), elicitationId: z.string() }).optional(),
     options: z.array(permissionOptionSchema).min(1),
     /**
      * The agent is asking the user something: answer with `sessions.answer`.
@@ -245,6 +238,7 @@ export const sessionUpdateSchema = z.discriminatedUnion("sessionUpdate", [
   z.object({
     sessionUpdate: z.literal("ls_status"),
     state: sessionStateSchema,
+    turnActive: z.boolean().optional(),
   }),
   /** A background task as it is now (the whole record each time: the latest for its id holds). */
   z.object({
@@ -261,6 +255,10 @@ export const sessionUpdateSchema = z.discriminatedUnion("sessionUpdate", [
 export type SessionUpdate = z.infer<typeof sessionUpdateSchema>;
 export type SessionUpdateKind = SessionUpdate["sessionUpdate"];
 
+/** Live ACP notices are not session history and never change execution state. */
+export const sessionNoticeSchema = z.object({ severity: z.string(), title: z.string(), description: z.string().optional() });
+export type SessionNotice = z.infer<typeof sessionNoticeSchema>;
+
 /** One entry in a session's append-only event log. */
 export const sessionEventSchema = z.object({
   sessionId: z.string(),