@baique/pi-web-sky 0.1.35 → 0.1.36

package/lib/session-title.test.mjs

@@ -0,0 +1,284 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
+import { convertToLlm } from "@earendil-works/pi-coding-agent";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const {
+  appendTitleRequestToTrailingUser,
+  buildSessionTitleAgentOptions,
+  generateSessionTitle,
+  parseGeneratedSessionTitle,
+  sanitizeTitleMessages,
+} = await jiti.import("./session-title.ts");
+
+function assistantMessage(text) {
+  return {
+    role: "assistant",
+    content: [{ type: "text", text }],
+    api: "test",
+    provider: "test",
+    model: "test-model",
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    },
+    stopReason: "stop",
+    timestamp: Date.now(),
+  };
+}
+
+test("cleans common session title response wrappers", () => {
+  assert.equal(parseGeneratedSessionTitle("标题：修复 SSE 重连。"), "修复 SSE 重连");
+  assert.equal(parseGeneratedSessionTitle('```json\n{"title":"整理 Session 文件夹"}\n```'), "整理 Session 文件夹");
+  assert.equal(parseGeneratedSessionTitle('"Improve worktree session grouping"'), "Improve worktree session grouping");
+});
+
+test("rejects responses without a usable title", () => {
+  assert.throws(() => parseGeneratedSessionTitle("```\n---\n```"), /usable session title/);
+});
+
+test("folds the title request into a trailing user message without mutating the source", () => {
+  const source = [
+    { role: "assistant", content: [], timestamp: 1 },
+    { role: "user", content: [{ type: "text", text: "Fix the running-session race" }], timestamp: 2 },
+  ];
+
+  const prepared = appendTitleRequestToTrailingUser(source);
+
+  assert.deepEqual(prepared.map((message) => message.role), ["assistant", "user"]);
+  assert.match(prepared[1].content.at(-1).text, /Create a concise title/);
+  assert.equal(source[1].content.length, 1);
+  assert.notEqual(prepared[1], source[1]);
+});
+
+test("leaves a completed conversation unchanged before adding the title turn", () => {
+  const source = [
+    { role: "user", content: "Fix it", timestamp: 1 },
+    { role: "assistant", content: [], timestamp: 2 },
+  ];
+
+  assert.equal(appendTitleRequestToTrailingUser(source), source);
+});
+
+test("waits for the source reply before sending the title prompt", async () => {
+  let sourceReplyFinished = false;
+  let providerRoles;
+  const sourceAgent = {
+    state: {
+      systemPrompt: "system",
+      model: { provider: "test", id: "test-model" },
+      thinkingLevel: "off",
+      tools: [],
+      messages: [{ role: "user", content: "Implement auto name", timestamp: 1 }],
+    },
+    waitForIdle: async () => {
+      sourceAgent.state.messages.push(assistantMessage("The implementation is complete"));
+      sourceReplyFinished = true;
+    },
+    convertToLlm: (messages) => messages,
+    streamFunction: (_model, context) => {
+      assert.equal(sourceReplyFinished, true);
+      providerRoles = context.messages.map((message) => message.role);
+      const stream = createAssistantMessageEventStream();
+      queueMicrotask(() => {
+        stream.push({
+          type: "done",
+          reason: "stop",
+          message: assistantMessage("Wait for Complete Agent Reply"),
+        });
+      });
+      return stream;
+    },
+    sessionId: "source-session-id",
+  };
+
+  const result = await generateSessionTitle({ agent: sourceAgent });
+
+  assert.equal(result.title, "Wait for Complete Agent Reply");
+  assert.deepEqual(providerRoles, ["user", "assistant", "user"]);
+});
+
+test("generates a title when compaction removed all literal user messages", async () => {
+  let providerMessages;
+  const sourceAgent = {
+    state: {
+      systemPrompt: "system",
+      model: { provider: "test", id: "test-model" },
+      thinkingLevel: "off",
+      tools: [],
+      messages: [
+        {
+          role: "compactionSummary",
+          summary: "The user asked to fix title generation after compaction.",
+          tokensBefore: 100_000,
+          timestamp: 1,
+        },
+        assistantMessage("The implementation is complete"),
+      ],
+    },
+    waitForIdle: async () => {},
+    convertToLlm,
+    streamFunction: (_model, context) => {
+      providerMessages = context.messages;
+      const stream = createAssistantMessageEventStream();
+      queueMicrotask(() => {
+        stream.push({
+          type: "done",
+          reason: "stop",
+          message: assistantMessage("Title Generation After Compaction"),
+        });
+      });
+      return stream;
+    },
+    sessionId: "source-session-id",
+  };
+
+  const result = await generateSessionTitle({ agent: sourceAgent });
+
+  assert.equal(result.title, "Title Generation After Compaction");
+  assert.deepEqual(providerMessages.map((message) => message.role), ["user", "assistant", "user"]);
+  assert.match(providerMessages[0].content[0].text, /fix title generation after compaction/);
+});
+
+test("temporary title agent preserves the provider-facing prefix", async () => {
+  const model = { provider: "test", id: "cached-model" };
+  const messages = [{ role: "user", content: [{ type: "text", text: "Fix it" }] }];
+  const originalExecute = async () => ({ content: [], details: {} });
+  const tools = [{
+    name: "read",
+    label: "read",
+    description: "Read a file",
+    parameters: { type: "object", properties: {} },
+    execute: originalExecute,
+  }];
+  const convertToLlm = (value) => value;
+  const transformContext = async (value) => value;
+  const streamFunction = () => { throw new Error("not called"); };
+  const source = {
+    state: {
+      systemPrompt: "cached system prompt",
+      model,
+      thinkingLevel: "high",
+      tools,
+      messages,
+    },
+    convertToLlm,
+    transformContext,
+    streamFunction,
+    steeringMode: "one-at-a-time",
+    followUpMode: "one-at-a-time",
+    sessionId: "source-session-id",
+    transport: "sse",
+    toolExecution: "parallel",
+  };
+
+  const options = buildSessionTitleAgentOptions(source);
+
+  assert.equal(options.initialState.systemPrompt, source.state.systemPrompt);
+  assert.equal(options.initialState.model, model);
+  assert.equal(options.initialState.thinkingLevel, "high");
+  assert.equal(options.initialState.messages, messages);
+  assert.equal(options.convertToLlm, convertToLlm);
+  assert.equal(options.transformContext, transformContext);
+  assert.equal(options.streamFn, streamFunction);
+  assert.equal(options.sessionId, "source-session-id");
+  const withoutExecute = (tool) => Object.fromEntries(
+    Object.entries(tool).filter(([key]) => key !== "execute"),
+  );
+  assert.deepEqual(
+    options.initialState.tools.map(withoutExecute),
+    tools.map(withoutExecute),
+  );
+  assert.notEqual(options.initialState.tools[0].execute, originalExecute);
+  await assert.rejects(
+    options.initialState.tools[0].execute("call", {}, undefined, undefined),
+    /cannot be executed/,
+  );
+});
+
+test("keeps only tool calls with adjacent matching results", () => {
+  const messages = [
+    { role: "user", content: "inspect both files", timestamp: 1 },
+    {
+      ...assistantMessage("Inspecting files"),
+      content: [
+        { type: "text", text: "Inspecting files" },
+        { type: "toolCall", id: "call-complete", name: "read", arguments: { path: "a.txt" } },
+        { type: "toolCall", id: "call-incomplete", name: "read", arguments: { path: "b.txt" } },
+      ],
+      stopReason: "toolUse",
+    },
+    {
+      role: "toolResult",
+      toolCallId: "call-complete",
+      toolName: "read",
+      content: [{ type: "text", text: "file contents" }],
+      isError: false,
+      timestamp: 2,
+    },
+  ];
+
+  const sanitized = sanitizeTitleMessages(messages);
+
+  assert.deepEqual(
+    sanitized[1].content.filter((block) => block.type === "toolCall").map((block) => block.id),
+    ["call-complete"],
+  );
+  assert.equal(sanitized[2], messages[2]);
+  assert.equal(messages[1].content.length, 3);
+});
+
+test("removes incomplete tool calls before invoking the title provider", async () => {
+  let providerMessages;
+  const sourceAgent = {
+    state: {
+      systemPrompt: "system",
+      model: { provider: "test", id: "test-model" },
+      thinkingLevel: "off",
+      tools: [],
+      messages: [
+        { role: "user", content: "run a command", timestamp: 1 },
+        {
+          ...assistantMessage(""),
+          content: [{
+            type: "toolCall",
+            id: "call-incomplete",
+            name: "bash",
+            arguments: { command: "sleep 10" },
+          }],
+          stopReason: "toolUse",
+        },
+      ],
+    },
+    waitForIdle: async () => {},
+    convertToLlm: (messages) => messages,
+    streamFunction: (_model, context) => {
+      providerMessages = context.messages.map((message) => ({
+        role: message.role,
+        content: message.content,
+      }));
+      const stream = createAssistantMessageEventStream();
+      queueMicrotask(() => {
+        stream.push({
+          type: "done",
+          reason: "stop",
+          message: assistantMessage("Sanitized Tool Call History"),
+        });
+      });
+      return stream;
+    },
+    sessionId: "source-session-id",
+  };
+
+  const result = await generateSessionTitle({ agent: sourceAgent });
+
+  assert.equal(result.title, "Sanitized Tool Call History");
+  assert.deepEqual(providerMessages.map((message) => message.role), ["user"]);
+  assert.match(providerMessages[0].content, /Create a concise title/);
+});

package/lib/session-title.ts

@@ -0,0 +1,255 @@
+import {
+  Agent,
+  type AgentMessage,
+  type AgentOptions,
+  type AgentTool,
+} from "@earendil-works/pi-agent-core";
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+
+const TITLE_TIMEOUT_MS = 90_000;
+const MAX_TITLE_LENGTH = 80;
+
+const TITLE_PROMPT = `Create a concise title for this session based on the conversation above.
+
+Requirements:
+- Match the primary language used by the user.
+- Describe the user's concrete goal or the outcome, not the act of chatting.
+- Use 4-12 words for space-separated languages, or 8-24 characters for CJK text when practical.
+- Do not call any tools.
+- Return only the title as plain text, with no quotes, label, markdown, or explanation.`;
+
+export interface GeneratedSessionTitle {
+  title: string;
+  usage?: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+  };
+}
+
+function createShadowTools(tools: AgentTool[]): AgentTool[] {
+  return tools.map((tool) => ({
+    ...tool,
+    execute: async () => {
+      throw new Error("Tools cannot be executed while generating a session title");
+    },
+  }));
+}
+
+/**
+ * Build a temporary Agent configuration whose provider-facing prefix matches
+ * the source Agent. Tool implementations are replaced without changing their
+ * names, descriptions, or schemas, so a naming run cannot mutate the project.
+ */
+export function buildSessionTitleAgentOptions(source: Agent): AgentOptions {
+  const state = source.state;
+  return {
+    initialState: {
+      systemPrompt: state.systemPrompt,
+      model: state.model,
+      thinkingLevel: state.thinkingLevel,
+      tools: createShadowTools(state.tools),
+      messages: state.messages,
+    },
+    convertToLlm: source.convertToLlm,
+    transformContext: source.transformContext,
+    streamFn: source.streamFunction,
+    getApiKey: source.getApiKey,
+    onPayload: source.onPayload,
+    onResponse: source.onResponse,
+    steeringMode: source.steeringMode,
+    followUpMode: source.followUpMode,
+    sessionId: source.sessionId,
+    thinkingBudgets: source.thinkingBudgets,
+    transport: source.transport,
+    maxRetryDelayMs: source.maxRetryDelayMs,
+    toolExecution: source.toolExecution,
+  };
+}
+
+/**
+ * A running source session usually ends in the user message currently being
+ * answered. Fold the title request into a copy of that message so the title
+ * request does not send two consecutive user messages to the provider.
+ */
+export function appendTitleRequestToTrailingUser(messages: AgentMessage[]): AgentMessage[] {
+  const lastMessage = messages.at(-1);
+  if (!lastMessage || lastMessage.role !== "user") return messages;
+
+  const content = typeof lastMessage.content === "string"
+    ? `${lastMessage.content}\n\n${TITLE_PROMPT}`
+    : [...lastMessage.content, { type: "text" as const, text: TITLE_PROMPT }];
+
+  return [
+    ...messages.slice(0, -1),
+    { ...lastMessage, content },
+  ];
+}
+
+function stripWrappingQuotes(value: string): string {
+  const pairs: Array<[string, string]> = [
+    ['"', '"'],
+    ["'", "'"],
+    ["`", "`"],
+    ["\u201c", "\u201d"],
+    ["\u300c", "\u300d"],
+    ["\u300e", "\u300f"],
+  ];
+  for (const [start, end] of pairs) {
+    if (value.startsWith(start) && value.endsWith(end) && value.length > start.length + end.length) {
+      return value.slice(start.length, -end.length).trim();
+    }
+  }
+  return value;
+}
+
+export function parseGeneratedSessionTitle(raw: string): string {
+  let value = raw.trim();
+  const fenced = value.match(/^```(?:json|text)?\s*([\s\S]*?)\s*```$/i);
+  if (fenced) value = fenced[1].trim();
+
+  if (value.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(value) as { title?: unknown };
+      if (typeof parsed.title === "string") value = parsed.title.trim();
+    } catch {
+      // Fall back to plain-text cleanup below.
+    }
+  }
+
+  value = value.split(/\r?\n/, 1)[0] ?? "";
+  value = value.replace(/^(?:session\s+title|title|标题)\s*[:：-]\s*/i, "");
+  value = stripWrappingQuotes(value).replace(/\s+/g, " ").trim();
+  value = value.replace(/[。.!]+$/u, "").trim();
+
+  if (!/[\p{L}\p{N}]/u.test(value)) {
+    throw new Error("The model did not return a usable session title");
+  }
+
+  const characters = Array.from(value);
+  if (characters.length > MAX_TITLE_LENGTH) {
+    value = characters.slice(0, MAX_TITLE_LENGTH).join("").trim();
+  }
+  return value;
+}
+
+function getAssistantResult(agent: Agent, historyLength: number): GeneratedSessionTitle {
+  const generatedMessages = agent.state.messages.slice(historyLength);
+  for (let i = generatedMessages.length - 1; i >= 0; i--) {
+    const message = generatedMessages[i];
+    if (message.role !== "assistant") continue;
+    if (message.stopReason === "error") {
+      throw new Error(message.errorMessage || "The title model request failed");
+    }
+    const text = message.content
+      .filter((block) => block.type === "text")
+      .map((block) => block.text)
+      .join("\n")
+      .trim();
+    if (!text) continue;
+    return {
+      title: parseGeneratedSessionTitle(text),
+      ...(message.usage ? {
+        usage: {
+          input: message.usage.input,
+          output: message.usage.output,
+          cacheRead: message.usage.cacheRead,
+          cacheWrite: message.usage.cacheWrite,
+          total: message.usage.totalTokens,
+        },
+      } : {}),
+    };
+  }
+  throw new Error("The model did not return a session title");
+}
+
+export function sanitizeTitleMessages(messages: AgentMessage[]): AgentMessage[] {
+  const sanitized: AgentMessage[] = [];
+  let expectedToolResultIds: Set<string> | undefined;
+
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+
+    if (message.role === "assistant") {
+      const followingToolResultIds = new Set<string>();
+      for (let resultIndex = index + 1; resultIndex < messages.length; resultIndex++) {
+        const resultMessage = messages[resultIndex];
+        if (resultMessage.role !== "toolResult") break;
+        followingToolResultIds.add(resultMessage.toolCallId);
+      }
+
+      expectedToolResultIds = new Set<string>();
+      const content = message.content.filter((block) => {
+        if (block.type !== "toolCall") return true;
+        if (!followingToolResultIds.has(block.id)) return false;
+        expectedToolResultIds!.add(block.id);
+        return true;
+      });
+
+      if (content.length > 0) {
+        sanitized.push({ ...message, content });
+      }
+      continue;
+    }
+
+    if (message.role === "toolResult") {
+      if (expectedToolResultIds?.delete(message.toolCallId)) {
+        sanitized.push(message);
+      }
+      continue;
+    }
+
+    expectedToolResultIds = undefined;
+    sanitized.push(message);
+  }
+
+  return sanitized;
+}
+
+export async function generateSessionTitle(source: AgentSession): Promise<GeneratedSessionTitle> {
+  const sourceAgent = source.agent;
+  await sourceAgent.waitForIdle();
+
+  const sanitizedMessages = sanitizeTitleMessages(sourceAgent.state.messages);
+  const historyLength = sanitizedMessages.length;
+  if (!sanitizedMessages.some(
+    (message) => message.role === "user" || message.role === "compactionSummary",
+  )) {
+    throw new Error("The session has no user messages to name");
+  }
+
+  const options = buildSessionTitleAgentOptions(sourceAgent);
+  options.initialState!.messages = sanitizedMessages;
+  const continuesFromTrailingUser = sanitizedMessages.at(-1)?.role === "user";
+  if (continuesFromTrailingUser) {
+    options.initialState!.messages = appendTitleRequestToTrailingUser(sanitizedMessages);
+  }
+
+  const temporaryAgent = new Agent(options);
+  const runPromise = continuesFromTrailingUser
+    ? temporaryAgent.continue()
+    : temporaryAgent.prompt(TITLE_PROMPT);
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+
+  try {
+    await Promise.race([
+      runPromise,
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => {
+          temporaryAgent.abort();
+          reject(new Error("Session title generation timed out"));
+        }, TITLE_TIMEOUT_MS);
+      }),
+    ]);
+  } catch (error) {
+    temporaryAgent.abort();
+    await runPromise.catch(() => {});
+    throw error;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+
+  return getAssistantResult(temporaryAgent, historyLength);
+}

package/lib/skill-frontmatter.test.mjs

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+
+import { setDisableModelInvocation } from "./skill-frontmatter.ts";
+
+describe("setDisableModelInvocation", () => {
+  const withFrontmatter = "---\nname: my-skill\ndescription: Does things\n---\n\nBody text.\n";
+
+  it("adds the key after the opening fence when absent", () => {
+    const updated = setDisableModelInvocation(withFrontmatter, true);
+    assert.equal(
+      updated,
+      "---\ndisable-model-invocation: true\nname: my-skill\ndescription: Does things\n---\n\nBody text.\n",
+    );
+    assert.equal(parseFrontmatter(updated).frontmatter["disable-model-invocation"], true);
+  });
+
+  it("creates a frontmatter block when the file has none", () => {
+    const updated = setDisableModelInvocation("Just a body.\n", true);
+    const { frontmatter, body } = parseFrontmatter(updated);
+    assert.equal(frontmatter["disable-model-invocation"], true);
+    assert.equal(body, "Just a body.");
+  });
+
+  it("replaces an explicit false value instead of adding a duplicate key", () => {
+    const content = "---\nname: my-skill\ndisable-model-invocation: false\ndescription: Does things\n---\n\nBody text.\n";
+    const updated = setDisableModelInvocation(content, true);
+    // A duplicate key would make the whole file unparseable and the loader
+    // would drop the skill, so this must parse to a single true value.
+    const { frontmatter } = parseFrontmatter(updated);
+    assert.equal(frontmatter["disable-model-invocation"], true);
+    assert.equal(
+      updated.match(/^disable-model-invocation[^\n]*/gm)?.length,
+      1,
+      "must not emit a duplicate key",
+    );
+  });
+
+  it("keeps a single key when disabling an already-true skill", () => {
+    const content = "---\nname: my-skill\ndisable-model-invocation: true\ndescription: Does things\n---\n\nBody text.\n";
+    const updated = setDisableModelInvocation(content, true);
+    assert.equal(parseFrontmatter(updated).frontmatter["disable-model-invocation"], true);
+    assert.equal(updated.match(/^disable-model-invocation[^\n]*/gm)?.length, 1);
+  });
+
+  it("removes the key when disabling is turned off", () => {
+    const content = "---\nname: my-skill\ndisable-model-invocation: true\ndescription: Does things\n---\n\nBody text.\n";
+    const updated = setDisableModelInvocation(content, false);
+    assert.deepEqual(parseFrontmatter(updated).frontmatter, {
+      name: "my-skill",
+      description: "Does things",
+    });
+  });
+
+  it("removes the key when it is the last frontmatter line before the closing fence", () => {
+    const content = "---\nname: my-skill\ndescription: Does things\ndisable-model-invocation: true\n---\n\nBody text.\n";
+    const updated = setDisableModelInvocation(content, false);
+    assert.equal(updated, withFrontmatter);
+  });
+
+  it("is a no-op when disabling is off and the key is absent", () => {
+    assert.equal(setDisableModelInvocation(withFrontmatter, false), withFrontmatter);
+  });
+
+  it("preserves unrelated frontmatter formatting and body lines that mention the key", () => {
+    const content = "---\nname: my-skill\n# comment\nallowed-tools: [ read, write ]\ndisable-model-invocation: false\n---\nUse `disable-model-invocation: true` to hide me.\n";
+    const updated = setDisableModelInvocation(content, true);
+    const { frontmatter, body } = parseFrontmatter(updated);
+    assert.equal(frontmatter["disable-model-invocation"], true);
+    assert.deepEqual(frontmatter["allowed-tools"], ["read", "write"]);
+    assert.match(updated, /# comment/);
+    assert.equal(body, "Use `disable-model-invocation: true` to hide me.");
+  });
+});

package/lib/skill-frontmatter.ts

@@ -0,0 +1,40 @@
+import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+
+const KEY = "disable-model-invocation";
+
+/**
+ * Toggle the `disable-model-invocation` frontmatter key with a surgical line
+ * edit that preserves the original YAML formatting of every other field.
+ *
+ * The key is detected by presence rather than truthiness: an explicit
+ * `disable-model-invocation: false` must be updated in place. Prepending a
+ * second key (as a truthiness check would) creates a duplicate YAML key that
+ * makes the whole file unparseable, and the skill loader then drops the skill.
+ */
+export function setDisableModelInvocation(content: string, disable: boolean): string {
+  const { frontmatter } = parseFrontmatter<Record<string, unknown>>(content);
+  const hasKey = Object.prototype.hasOwnProperty.call(frontmatter, KEY);
+  if (!disable && !hasKey) return content;
+
+  // Only edit inside the frontmatter block, so a body line that happens to
+  // document the key is never touched.
+  const closing = content.startsWith("---") ? content.indexOf("\n---", 3) : -1;
+  const head = closing === -1 ? content : content.slice(0, closing);
+  const tail = closing === -1 ? "" : content.slice(closing);
+
+  if (disable) {
+    if (hasKey) {
+      return head.replace(new RegExp(`^${KEY}[ \\t]*:[^\\n]*`, "m"), `${KEY}: true`) + tail;
+    }
+    const withKey = head.replace(/^---\r?\n/, `---\n${KEY}: true\n`);
+    if (withKey === head) {
+      // No frontmatter block at all — create one.
+      return `---\n${KEY}: true\n---\n${content}`;
+    }
+    return withKey + tail;
+  }
+
+  // Drop the line together with its preceding newline so no blank line is
+  // left behind; the key is never the first line of the frontmatter block.
+  return head.replace(new RegExp(`\\n${KEY}[ \\t]*:[^\\n]*`), "") + tail;
+}