pi-sessions 0.8.0 → 0.10.0

package/extensions/pi-sessions.ts

@@ -0,0 +1,125 @@
+import {
+  type ExtensionAPI,
+  type ModelRuntime,
+  SessionManager,
+} from "@earendil-works/pi-coding-agent";
+import { installAsk } from "./session-ask/install.ts";
+import { installAutoTitle } from "./session-auto-title/install.ts";
+import { installHandoff } from "./session-handoff/install.ts";
+import { installHooks } from "./session-hooks/install.ts";
+import { installIndex } from "./session-index/install.ts";
+import { installMessaging } from "./session-messaging/install.ts";
+import {
+  createSessionCancelTool,
+  createSessionSendMessageTool,
+} from "./session-messaging/pi/tools.ts";
+import { installSearch } from "./session-search/install.ts";
+import type { SessionLifecycle } from "./shared/composition.ts";
+import { createSessionModelRuntime, type ModelRuntimeProvider } from "./shared/model-runtime.ts";
+import { loadSettings } from "./shared/settings.ts";
+import { installSubagents } from "./subagents/install.ts";
+
+/**
+ * The single advertised entrypoint. It loads settings once, constructs each feature in
+ * dependency order, and wires them by constructor parameters.
+ * It also owns the single `session_start`/`session_shutdown` subscription so lifecycle order
+ * is deterministic: broker registration (messaging) resolves before any other feature hook.
+ */
+export default function piSessions(pi: ExtensionAPI): void {
+  const settings = loadSettings();
+  let sessionEpoch = 0;
+
+  // The mirrored ModelRuntime is expensive to build and only changes across session
+  // boundaries, so cache it per epoch (the root's own invalidation signal) instead of
+  // rebuilding it on every auto-title, /title, session_ask, and handoff draft.
+  let cachedModelRuntime: { epoch: number; runtime: Promise<ModelRuntime> } | undefined;
+  const getModelRuntime: ModelRuntimeProvider = (modelRegistry) => {
+    if (cachedModelRuntime?.epoch !== sessionEpoch) {
+      cachedModelRuntime = {
+        epoch: sessionEpoch,
+        runtime: createSessionModelRuntime(modelRegistry),
+      };
+    }
+    return cachedModelRuntime.runtime;
+  };
+
+  const index = installIndex(pi, { settings });
+  const messaging = settings.features.messaging
+    ? installMessaging(pi, { settings, index })
+    : undefined;
+
+  const lifecycles: SessionLifecycle[] = [];
+  if (messaging) {
+    lifecycles.push(messaging);
+  }
+  const subagents =
+    settings.features.subagents && messaging
+      ? installSubagents(pi, { settings, messaging })
+      : undefined;
+  if (subagents) {
+    lifecycles.push(subagents);
+  }
+  if (messaging) {
+    pi.registerTool(
+      createSessionSendMessageTool(subagents ?? messaging, {
+        wakeCapable: Boolean(subagents),
+        getCachedRelationTo: messaging.getCachedRelationTo,
+      }),
+    );
+    pi.registerTool(createSessionCancelTool(subagents ?? messaging));
+  }
+  if (settings.features.handoff) {
+    const board = {
+      roster: subagents?.roster,
+      cancelSubagent: subagents
+        ? (sessionId: string) => subagents.cancelSession(sessionId)
+        : undefined,
+      listLiveSessions: messaging ? () => messaging.listSessions() : undefined,
+      readSessionEntries: (sessionFile: string) => SessionManager.open(sessionFile).getEntries(),
+    };
+    lifecycles.push(
+      installHandoff(pi, {
+        settings,
+        index,
+        getModelRuntime,
+        ...(subagents ? { getLaunchTargets: () => subagents.getLaunchTargets() } : {}),
+        board,
+      }),
+    );
+  }
+  if (settings.features.search) {
+    installSearch(pi, { settings, index, messaging, roster: subagents?.roster });
+  }
+  if (settings.features.ask) {
+    installAsk(pi, { settings, index, getModelRuntime });
+  }
+  if (settings.features.autoTitle) {
+    lifecycles.push(
+      installAutoTitle(pi, {
+        settings,
+        getModelRuntime,
+        getSessionEpoch: () => sessionEpoch,
+      }),
+    );
+  }
+  if (settings.features.hooks) {
+    lifecycles.push(installHooks(pi, { settings, index }));
+  }
+  // Messaging leads every session_start so the broker connection is registered before any
+  // other feature hook runs. A side effect is that messaging's first relation snapshot can
+  // predate hooks' index sync for this session; getCachedRelationTo self-heals on miss, so
+  // this ordering is intentional — do not reorder to "fix" it.
+  pi.on("session_start", async (event, ctx) => {
+    sessionEpoch += 1;
+    for (const lifecycle of lifecycles) {
+      await lifecycle.onSessionStart?.(event, ctx);
+    }
+  });
+
+  pi.on("session_shutdown", async (event, ctx) => {
+    sessionEpoch += 1;
+    for (let index = lifecycles.length - 1; index >= 0; index -= 1) {
+      await lifecycles[index]?.onSessionShutdown?.(event, ctx);
+    }
+  });
+}

package/extensions/session-ask/agent.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext, ModelRuntime } from "@earendil-works/pi-coding-agent";
 import {
   createAgentSession,
   DefaultResourceLoader,
@@ -8,7 +8,8 @@ import {
   SessionManager,
 } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
-import { resolveConfiguredModel } from "../shared/model.ts";
+import { resolveAuthenticatedModel } from "../shared/model-resolution.ts";
+import { freshenModel } from "../shared/model-runtime.ts";
 import {
   type SessionLineageRow,
   searchSessionChunks,
@@ -122,6 +123,7 @@ export interface SessionAskAgentResult {
 
 export async function runSessionAskAgent(params: {
   ctx: ExtensionContext;
+  modelRuntime: ModelRuntime;
   target: SessionLineageRow;
   question: string;
   indexPath: string;
@@ -129,13 +131,22 @@ export async function runSessionAskAgent(params: {
   thinkingLevel: ThinkingLevel | undefined;
   signal?: AbortSignal | undefined;
 }): Promise<SessionAskAgentResult | undefined> {
+  params.signal?.throwIfAborted();
   const navigationData = loadSessionNavigationData(params.target.sessionPath);
-  const model =
-    resolveConfiguredModel(params.ctx.modelRegistry.getAvailable(), params.askSettings?.model) ??
-    params.ctx.model;
+  const configured = params.askSettings?.model
+    ? resolveAuthenticatedModel({
+        modelRuntime: params.modelRuntime,
+        modelPattern: params.askSettings.model,
+      })
+    : undefined;
+  const currentModel = params.ctx.model
+    ? freshenModel(params.modelRuntime, params.ctx.model)
+    : undefined;
+  const model = (configured?.ok ? configured.model : undefined) ?? currentModel;
   if (!model) {
     throw new Error("No active model is available for session_ask.");
   }
+  const configuredThinkingLevel = configured?.ok ? configured.thinkingLevel : undefined;
 
   let capturedArguments: ProvideResultsArgs | undefined;
   const searchSessionTool = defineTool({
@@ -234,7 +245,7 @@ export async function runSessionAskAgent(params: {
     description: "Return the final answer for session_ask.",
     promptSnippet: "Provide session ask result",
     promptGuidelines: [
-      "Call provide_results exactly once when you are ready to answer. It is the final tool call and ends the session_ask sub-agent turn.",
+      "Call provide_results exactly once when you are ready to answer. It is the final tool call and ends the session_ask subagent turn.",
     ],
     parameters: PROVIDE_RESULTS_PARAMETERS,
     execute: async (_toolCallId, toolParams: ProvideResultsArgs) => {
@@ -261,9 +272,12 @@ export async function runSessionAskAgent(params: {
     noSkills: true,
     appendSystemPromptOverride: (base) => [...base, SESSION_ASK_NAVIGATION_SYSTEM_PROMPT],
   });
+  params.signal?.throwIfAborted();
   await resourceLoader.reload();
+  params.signal?.throwIfAborted();
 
-  const thinkingLevel = params.askSettings?.thinkingLevel ?? params.thinkingLevel;
+  const thinkingLevel =
+    params.askSettings?.thinkingLevel ?? configuredThinkingLevel ?? params.thinkingLevel;
   const sessionManager = params.askSettings?.persistRuns
     ? SessionManager.create(cwd, getDefaultSessionAskRunsDir())
     : SessionManager.inMemory(cwd);
@@ -273,7 +287,7 @@ export async function runSessionAskAgent(params: {
   const { session } = await createAgentSession({
     cwd,
     model,
-    modelRegistry: params.ctx.modelRegistry,
+    modelRuntime: params.modelRuntime,
     ...(thinkingLevel ? { thinkingLevel } : {}),
     tools: SESSION_ASK_AGENT_TOOLS,
     customTools: [searchSessionTool, sessionReadTool, provideResultsTool],
@@ -281,29 +295,35 @@ export async function runSessionAskAgent(params: {
     sessionManager,
   });
 
-  const abortHandler = (): void => {
-    void session.abort();
+  // Exactly one session.abort() runs no matter how many abort paths fire.
+  let nestedAbort: Promise<void> | undefined;
+  const startNestedAbort = (): void => {
+    nestedAbort ??= Promise.resolve(session.abort()).catch(() => {});
   };
 
   try {
-    params.signal?.addEventListener("abort", abortHandler, { once: true });
+    params.signal?.addEventListener("abort", startNestedAbort, { once: true });
     if (params.signal?.aborted) {
-      await session.abort();
-      return undefined;
+      startNestedAbort();
     }
 
     for (let attempt = 1; attempt <= MAX_SESSION_ASK_ATTEMPTS; attempt += 1) {
+      params.signal?.throwIfAborted();
       const prompt =
         attempt === 1
           ? buildNavigationPrompt(navigationData, params.question)
           : `You did not call ${PROVIDE_RESULTS_TOOL_NAME}. Continue from your prior work and call ${PROVIDE_RESULTS_TOOL_NAME} exactly once with the final markdown answer.`;
       await session.prompt(prompt);
+      params.signal?.throwIfAborted();
       if (capturedArguments) {
         break;
       }
     }
   } finally {
-    params.signal?.removeEventListener("abort", abortHandler);
+    params.signal?.removeEventListener("abort", startNestedAbort);
+    if (nestedAbort) {
+      await nestedAbort;
+    }
     session.dispose();
   }
 

package/extensions/{session-ask.ts → session-ask/install.ts}

@@ -1,39 +1,38 @@
-import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-import { getKeybindings, type Keybinding, Text } from "@earendil-works/pi-tui";
+import { type ExtensionAPI, SessionManager } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { runSessionAskAgent } from "./session-ask/agent.ts";
+import { isSessionStarting } from "../session-handoff/metadata.ts";
+import type { IndexHandle } from "../shared/composition.ts";
+import type { ModelRuntimeProvider } from "../shared/model-runtime.ts";
 import {
   getSessionById,
   type SessionLineageRow,
   withSessionIndex,
-} from "./shared/session-index/index.ts";
-import { formatSessionTitleOrShortId, isExactSessionId } from "./shared/session-ui.ts";
-import { loadSettings } from "./shared/settings.ts";
-
-const COLLAPSED_ANSWER_PREVIEW_ROWS = 6;
+} from "../shared/session-index/index.ts";
+import { isExactSessionId } from "../shared/session-ui.ts";
+import type { SessionSettings } from "../shared/settings.ts";
+import { runSessionAskAgent } from "./agent.ts";
+import { renderSessionAskResult } from "./renderer.ts";
+import type {
+  SessionAskProgressDetails,
+  SessionAskRelevantFile,
+  SessionAskResultDetails,
+} from "./tool-contract.ts";
 
 interface SessionAskToolParams {
   session: string;
   question: string;
 }
 
-interface SessionAskRelevantFile {
-  path: string;
-  reason: string;
-}
-
-interface SessionAskToolDetails {
-  answer?: string | undefined;
-  debugSessionPath?: string | undefined;
-  question?: string | undefined;
-  relevantFiles?: SessionAskRelevantFile[] | undefined;
-  sessionId?: string | undefined;
-  sessionName?: string | undefined;
-  sessionPath?: string | undefined;
-}
-
-export default function sessionAskExtension(pi: ExtensionAPI): void {
-  const settings = loadSettings();
+export function installAsk(
+  pi: ExtensionAPI,
+  deps: {
+    settings: SessionSettings;
+    index: IndexHandle;
+    getModelRuntime: ModelRuntimeProvider;
+  },
+): void {
+  const { settings } = deps;
+  const indexPath = deps.index.path;
 
   pi.registerTool({
     name: "session_ask",
@@ -60,12 +59,40 @@ export default function sessionAskExtension(pi: ExtensionAPI): void {
         throw new Error("session_ask requires a question.");
       }
 
-      const resolvedTarget = resolveSessionAskTarget(sessionId, settings.index.path);
+      const resolvedTarget = resolveSessionAskTarget(sessionId, indexPath);
       if (!resolvedTarget.resolved) {
         throw new Error(resolvedTarget.error ?? "Unable to resolve session id.");
       }
 
-      const progressDetails: SessionAskToolDetails = {
+      const startingAnswer = getStartingSessionAnswer(resolvedTarget.resolved.sessionPath);
+      if (startingAnswer) {
+        const details: SessionAskResultDetails = {
+          answer: startingAnswer,
+          relevantFiles: [],
+          sessionId: resolvedTarget.resolved.sessionId,
+          sessionName: resolvedTarget.resolved.sessionName,
+          sessionPath: resolvedTarget.resolved.sessionPath,
+          question,
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                formatSessionAskHeader(
+                  resolvedTarget.resolved.sessionId,
+                  resolvedTarget.resolved.sessionName,
+                  question,
+                ),
+                startingAnswer,
+              ].join("\n\n"),
+            },
+          ],
+          details,
+        };
+      }
+
+      const progressDetails: SessionAskProgressDetails = {
         question,
         sessionId: resolvedTarget.resolved.sessionId,
         sessionName: resolvedTarget.resolved.sessionName,
@@ -90,26 +117,26 @@ export default function sessionAskExtension(pi: ExtensionAPI): void {
         details: progressDetails,
       });
 
+      const modelRuntime = await deps.getModelRuntime(ctx.modelRegistry);
       const agentResult = await runSessionAskAgent({
         ctx,
+        modelRuntime,
         target: resolvedTarget.resolved,
         question,
-        indexPath: settings.index.path,
+        indexPath,
         askSettings: settings.ask,
         thinkingLevel: pi.getThinkingLevel(),
         signal,
       });
 
-      if (signal?.aborted) {
-        throw new Error("Session ask was cancelled.");
-      }
-
       const answer = agentResult?.answer || "Could not determine an answer from the session.";
       const relevantFiles = agentResult?.relevantFiles ?? [];
 
-      const details: SessionAskToolDetails = {
+      const details: SessionAskResultDetails = {
         answer,
-        debugSessionPath: agentResult?.debugSessionPath,
+        ...(agentResult?.debugSessionPath
+          ? { debugSessionPath: agentResult.debugSessionPath }
+          : {}),
         relevantFiles,
         sessionId: resolvedTarget.resolved.sessionId,
         sessionName: resolvedTarget.resolved.sessionName,
@@ -133,42 +160,21 @@ export default function sessionAskExtension(pi: ExtensionAPI): void {
         details,
       };
     },
-    renderResult(result, { expanded, isPartial }, theme, context) {
-      const details = result.details as SessionAskToolDetails | undefined;
-      const content = result.content[0];
-      if (content?.type !== "text") {
-        return new Text(theme.fg("error", "No session output"), 0, 0);
-      }
-
-      if (context.isError) {
-        return new Text(theme.fg("error", content.text), 0, 0);
-      }
-
-      if (isPartial) {
-        const lines = [theme.bold(theme.fg("warning", "Reading session..."))];
-        if (details?.sessionId || details?.sessionName) {
-          const identity = formatSessionTitleOrShortId(details.sessionName, details.sessionId);
-          lines.push(`title: ${theme.fg("accent", identity)}`);
-        }
-        if (details?.question) {
-          lines.push(theme.fg("muted", `prompt: ${details.question}`));
-        }
-        return new Text(lines.join("\n"), 0, 0);
-      }
-
-      const answer = (details?.answer ?? "").trim() || "No answer generated.";
-      const identity = formatSessionTitleOrShortId(details?.sessionName, details?.sessionId);
-      const lines = [`title: ${theme.bold(identity)}`];
-      if (details?.question) {
-        lines.push(theme.fg("muted", `prompt: ${details.question}`));
-        lines.push("");
-      }
-      lines.push(...formatSessionAskAnswerPreview(answer, expanded, theme));
-      return new Text(lines.join("\n"), 0, 0);
-    },
+    renderResult: renderSessionAskResult,
   });
 }
 
+function getStartingSessionAnswer(sessionPath: string): string | undefined {
+  try {
+    if (isSessionStarting(SessionManager.open(sessionPath).getBranch())) {
+      return "This session is still starting: a handoff is in progress and it has not received its kickoff. Retry once the session is no longer starting.";
+    }
+  } catch {
+    // The navigation agent preserves the existing failure behavior for unreadable sessions.
+  }
+  return undefined;
+}
+
 function resolveSessionAskTarget(
   sessionId: string,
   indexPath: string,
@@ -220,26 +226,3 @@ function formatSessionAskAnswer(
   }
   return lines.join("\n");
 }
-
-function formatSessionAskAnswerPreview(answer: string, expanded: boolean, theme: Theme): string[] {
-  const lines = answer.split(/\r?\n/);
-  if (expanded || lines.length <= COLLAPSED_ANSWER_PREVIEW_ROWS) {
-    return lines;
-  }
-
-  return [
-    ...lines.slice(0, COLLAPSED_ANSWER_PREVIEW_ROWS),
-    formatOverflowHint(lines.length - COLLAPSED_ANSWER_PREVIEW_ROWS, lines.length, theme),
-  ];
-}
-
-function formatOverflowHint(remaining: number, total: number, theme: Theme): string {
-  return `${theme.fg("muted", `... (${remaining} more lines, ${total} total,`)} ${theme.fg(
-    "dim",
-    formatKeyHint("app.tools.expand"),
-  )}${theme.fg("muted", " to expand)")}`;
-}
-
-function formatKeyHint(keybinding: Keybinding): string {
-  return getKeybindings().getKeys(keybinding).join("/");
-}

package/extensions/session-ask/navigate.ts

@@ -7,6 +7,7 @@ import {
   SessionManager,
   type SessionMessageEntry,
 } from "@earendil-works/pi-coding-agent";
+import { HANDOFF_KICKOFF_CUSTOM_TYPE } from "../session-handoff/kickoff.ts";
 import { contentToText, isRecord, truncateBlock, truncateInline } from "../shared/text.ts";
 
 const MAX_TOOL_RESULT_PREVIEW_CHARS = 300;
@@ -726,7 +727,8 @@ function renderEntryContent(entry: SessionEntry, body: SessionReadBodyMode = "fu
     return renderMessageEntry(entry, body);
   }
   if (entry.type === "custom_message") {
-    return `[Custom]: ${String(entry.content ?? "")}`;
+    const label = entry.customType === HANDOFF_KICKOFF_CUSTOM_TYPE ? "Handoff kickoff" : "Custom";
+    return `[${label}]: ${String(entry.content ?? "")}`;
   }
   if (entry.type === "compaction" || entry.type === "branch_summary") {
     return String(entry.summary ?? "");

package/extensions/session-ask/presenter.ts

@@ -0,0 +1,23 @@
+import type { ExpandableContentPresentation } from "../shared/rendering/expandable-content-layout.ts";
+import type { RenderTheme } from "../shared/rendering/theme.ts";
+import { formatSessionTitleOrShortId } from "../shared/session-ui.ts";
+import type { SessionAskViewModel } from "./view-model.ts";
+
+export function buildSessionAskPresentation(
+  model: SessionAskViewModel,
+  theme: RenderTheme,
+): ExpandableContentPresentation {
+  const identity = formatSessionTitleOrShortId(model.sessionName, model.sessionId);
+  return {
+    header: `title: ${theme.bold(identity)}`,
+    ...(model.question
+      ? {
+          metadata: [theme.fg("muted", `prompt: ${model.question}`)],
+        }
+      : {}),
+    body: {
+      text: model.answer,
+      collapsedRows: 6,
+    },
+  };
+}

package/extensions/session-ask/renderer.ts

@@ -0,0 +1,63 @@
+import type {
+  AgentToolResult,
+  Theme,
+  ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+import { type Component, Text } from "@earendil-works/pi-tui";
+import { ExpandableContentLayout } from "../shared/rendering/expandable-content-layout.ts";
+import { formatSessionTitleOrShortId } from "../shared/session-ui.ts";
+import { safeParseTypeBoxValue } from "../shared/typebox.ts";
+import { buildSessionAskPresentation } from "./presenter.ts";
+import {
+  SESSION_ASK_PROGRESS_DETAILS_SCHEMA,
+  SESSION_ASK_RESULT_DETAILS_SCHEMA,
+} from "./tool-contract.ts";
+import { buildSessionAskView } from "./view-model.ts";
+
+interface SessionAskToolRendererState {
+  layout?: ExpandableContentLayout | undefined;
+}
+
+interface SessionAskToolRenderContext {
+  state: SessionAskToolRendererState;
+  isError: boolean;
+}
+
+export function renderSessionAskResult(
+  result: AgentToolResult<unknown>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+  context: SessionAskToolRenderContext,
+): Component {
+  const content = result.content[0];
+  if (content?.type !== "text") {
+    return new Text(theme.fg("error", "No session output"), 0, 0);
+  }
+
+  if (context.isError) {
+    return new Text(theme.fg("error", content.text), 0, 0);
+  }
+
+  if (options.isPartial) {
+    const details = safeParseTypeBoxValue(SESSION_ASK_PROGRESS_DETAILS_SCHEMA, result.details);
+    const lines = [theme.bold(theme.fg("warning", "Reading session..."))];
+    if (details) {
+      const identity = formatSessionTitleOrShortId(details.sessionName, details.sessionId);
+      lines.push(`title: ${theme.fg("accent", identity)}`);
+    }
+    if (details?.question) {
+      lines.push(theme.fg("muted", `prompt: ${details.question}`));
+    }
+    return new Text(lines.join("\n"), 0, 0);
+  }
+
+  const details = safeParseTypeBoxValue(SESSION_ASK_RESULT_DETAILS_SCHEMA, result.details);
+  if (!details) {
+    return new Text(content.text, 0, 0);
+  }
+
+  const layout = context.state.layout ?? new ExpandableContentLayout(theme);
+  context.state.layout = layout;
+  layout.update(buildSessionAskPresentation(buildSessionAskView(details), theme), options.expanded);
+  return layout;
+}

package/extensions/session-ask/tool-contract.ts

@@ -0,0 +1,27 @@
+import { type Static, Type } from "typebox";
+
+export const SESSION_ASK_RELEVANT_FILE_SCHEMA = Type.Object({
+  path: Type.String(),
+  reason: Type.String(),
+});
+
+export const SESSION_ASK_PROGRESS_DETAILS_SCHEMA = Type.Object({
+  question: Type.String({ minLength: 1 }),
+  sessionId: Type.String({ minLength: 1 }),
+  sessionName: Type.String(),
+  sessionPath: Type.String({ minLength: 1 }),
+});
+
+export const SESSION_ASK_RESULT_DETAILS_SCHEMA = Type.Object({
+  answer: Type.String({ minLength: 1 }),
+  debugSessionPath: Type.Optional(Type.String({ minLength: 1 })),
+  question: Type.String({ minLength: 1 }),
+  relevantFiles: Type.Array(SESSION_ASK_RELEVANT_FILE_SCHEMA),
+  sessionId: Type.String({ minLength: 1 }),
+  sessionName: Type.String(),
+  sessionPath: Type.String({ minLength: 1 }),
+});
+
+export type SessionAskRelevantFile = Static<typeof SESSION_ASK_RELEVANT_FILE_SCHEMA>;
+export type SessionAskProgressDetails = Static<typeof SESSION_ASK_PROGRESS_DETAILS_SCHEMA>;
+export type SessionAskResultDetails = Static<typeof SESSION_ASK_RESULT_DETAILS_SCHEMA>;

package/extensions/session-ask/view-model.ts

@@ -0,0 +1,18 @@
+import { normalizeOptionalText } from "../shared/text.ts";
+import type { SessionAskResultDetails } from "./tool-contract.ts";
+
+export interface SessionAskViewModel {
+  sessionId: string;
+  sessionName?: string | undefined;
+  question: string;
+  answer: string;
+}
+
+export function buildSessionAskView(details: SessionAskResultDetails): SessionAskViewModel {
+  return {
+    sessionId: details.sessionId.trim(),
+    sessionName: normalizeOptionalText(details.sessionName),
+    question: details.question.trim(),
+    answer: details.answer.trim(),
+  };
+}