@linkshell/wire 0.2.7 → 0.2.9

package/src/peer.ts

@@ -91,13 +91,21 @@ export class RpcPeer {
   receive(text: string): void {
     for (const line of text.split("\n")) {
       if (!line.trim()) continue;
-      let message: Record<string, unknown>;
+      let message: Record<string, unknown> | Record<string, unknown>[];
       try {
-        message = JSON.parse(line) as Record<string, unknown>;
+        message = JSON.parse(line) as typeof message;
       } catch {
         continue;
       }
-      this.dispatch(message);
+      if (Array.isArray(message)) {
+        if (!message.length || message.length > 128) {
+          this.write({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "invalid JSON-RPC batch" } });
+          continue;
+        }
+        const responses: Record<string, unknown>[] = [];
+        void Promise.all(message.map((entry) => Promise.resolve(this.dispatch(entry, (response) => { responses.push(response); }))))
+          .then(() => { if (responses.length) this.write(responses); });
+      } else void this.dispatch(message);
     }
   }
 
@@ -116,7 +124,13 @@ export class RpcPeer {
     return this.closed;
   }
 
-  private dispatch(message: Record<string, unknown>): void {
+  hasPendingRequest(id: RpcId): boolean { return this.pending.has(id); }
+
+  private dispatch(message: Record<string, unknown>, respond = (response: Record<string, unknown>) => this.write(response)): void | Promise<void> {
+    if (!message || typeof message !== "object" || Array.isArray(message)) {
+      respond({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "invalid JSON-RPC request" } });
+      return;
+    }
     const id = message.id as RpcId | undefined;
     const method = typeof message.method === "string" ? message.method : undefined;
 
@@ -139,27 +153,27 @@ export class RpcPeer {
 
     const handler = this.options.onRequest;
     if (!handler) {
-      this.write({ jsonrpc: "2.0", id, error: { code: RPC_METHOD_NOT_FOUND, message: `no handler for ${method}` } });
+      respond({ jsonrpc: "2.0", id, error: { code: RPC_METHOD_NOT_FOUND, message: `no handler for ${method}` } });
       return;
     }
-    Promise.resolve()
+    return Promise.resolve()
       .then(() => handler(method, message.params, id))
       .then(
         (result) => {
           if (result === ABANDON) return;
-          this.write({ jsonrpc: "2.0", id, result: result ?? {} });
+          respond({ jsonrpc: "2.0", id, result: result ?? {} });
         },
         (error: unknown) => {
           const rpcError =
             error instanceof RpcError
               ? error
               : new RpcError(RPC_APP_ERROR, error instanceof Error ? error.message : String(error), { code: "internal" });
-          this.write({ jsonrpc: "2.0", id, error: rpcError.toObject() });
+          respond({ jsonrpc: "2.0", id, error: rpcError.toObject() });
         },
       );
   }
 
-  private write(message: Record<string, unknown>): void {
+  private write(message: Record<string, unknown> | Record<string, unknown>[]): void {
     if (this.closed) return;
     try {
       this.options.send(JSON.stringify(message));

package/src/questions.ts

@@ -0,0 +1,39 @@
+import type { Question, QuestionAnswer } from "./model.js";
+
+/** Shared validation keeps the phone's feedback and the host's acceptance identical. */
+export function questionAnswerError(question: Question, answer: QuestionAnswer | undefined): string | undefined {
+  const label = question.header ?? question.text;
+  const values = answer?.values ?? [];
+  const c = question.constraints;
+  if (values.length > 1 && question.kind !== "choices") return `${label}只能填写一个答案`;
+  if (question.options && values.some((value) => !question.options!.some((option) => option.value === value))) return `${label}包含无效选项`;
+  const present = c?.type === "array" ? answer !== undefined : c?.type === "string" ? values[0] !== undefined || !!answer?.other?.trim() : values.some((value) => value !== "") || !!answer?.other?.trim();
+  if (!present) return question.required ? `还没回答：${label}` : undefined;
+  if (!c) return;
+  const value = values[0] ?? "";
+  if (c.type === "number" || c.type === "integer") {
+    const number = Number(value);
+    if (!value.trim() || !Number.isFinite(number) || (c.type === "integer" && !Number.isInteger(number))) return `${label}需要填写${c.type === "integer" ? "整数" : "数字"}`;
+    if (c.minimum !== undefined && number < c.minimum) return `${label}不能小于 ${c.minimum}`;
+    if (c.maximum !== undefined && number > c.maximum) return `${label}不能大于 ${c.maximum}`;
+  }
+  if (c.type === "array") {
+    if (new Set(values).size !== values.length) return `${label}不能重复选择`;
+    if (c.minItems !== undefined && values.length < c.minItems) return `${label}至少选择 ${c.minItems} 项`;
+    if (c.maxItems !== undefined && values.length > c.maxItems) return `${label}最多选择 ${c.maxItems} 项`;
+  }
+  if (c.type === "string") {
+    const length = [...value].length;
+    if (c.minLength !== undefined && length < c.minLength) return `${label}至少需要 ${c.minLength} 个字符`;
+    if (c.maxLength !== undefined && length > c.maxLength) return `${label}最多允许 ${c.maxLength} 个字符`;
+    if (c.pattern) {
+      try { if (!new RegExp(c.pattern, "u").test(value)) return `${label}格式不符合要求`; }
+      catch { return `${label}的格式规则无效`; }
+    }
+    if (c.format === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) return `${label}需要有效的邮箱地址`;
+    if (c.format === "uri") { try { new URL(value); } catch { return `${label}需要完整的网址`; } }
+    if (c.format === "date" && (!/^\d{4}-\d{2}-\d{2}$/.test(value) || !Number.isFinite(Date.parse(value)) || new Date(value).toISOString().slice(0, 10) !== value)) return `${label}需要有效日期（YYYY-MM-DD）`;
+    if (c.format === "date-time" && (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/i.test(value) || !Number.isFinite(Date.parse(value)))) return `${label}需要包含时区的有效日期时间`;
+  }
+  return;
+}

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

@@ -1,54 +1,15 @@
 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(),
@@ -71,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(),
@@ -94,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(),
@@ -131,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(),
@@ -144,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"),
@@ -171,15 +158,22 @@ 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({
+    sessionUpdate: z.literal("ls_async_questions"),
+    questions: z.array(asyncQuestionSchema),
+  }),
   z.object({
     sessionUpdate: z.literal("ls_message_done"),
     parentToolCallId: z.string().optional(),
@@ -190,7 +184,7 @@ export const sessionUpdateSchema = z.discriminatedUnion("sessionUpdate", [
      * `request_user_input_async`): answered by an ordinary message that quotes
      * them (`asyncQuestionReply`). An app that predates them shows the text only.
      */
-    questions: z.array(z.object({ id: z.string(), title: z.string(), options: z.array(z.string()) })).optional(),
+    questions: z.array(asyncQuestionSchema).optional(),
   }),
   /** Selectable session settings (model, permission mode, effort…) as the agent reports them. */
   z.object({
@@ -214,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`.
@@ -240,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({
@@ -256,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(),