nolo-cli 0.1.44 → 0.1.46

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Bin Zhang
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/agent-runtime/agentConfigOptions.ts

@@ -1,12 +0,0 @@
-import type { AgentRuntimeAgentConfig } from "./hostAdapter";
-
-export function pickAgentRuntimeInferenceOptions(agentConfig: AgentRuntimeAgentConfig) {
-  return {
-    ...(agentConfig.temperature !== undefined ? { temperature: agentConfig.temperature } : {}),
-    ...(agentConfig.top_p !== undefined ? { top_p: agentConfig.top_p } : {}),
-    ...(agentConfig.frequency_penalty !== undefined ? { frequency_penalty: agentConfig.frequency_penalty } : {}),
-    ...(agentConfig.presence_penalty !== undefined ? { presence_penalty: agentConfig.presence_penalty } : {}),
-    ...(agentConfig.max_tokens !== undefined ? { max_tokens: agentConfig.max_tokens } : {}),
-    ...(agentConfig.reasoning_effort ? { reasoning_effort: agentConfig.reasoning_effort } : {}),
-  };
-}

package/agent-runtime/agentRecordConfig.ts

@@ -1,101 +0,0 @@
-import type { AgentRuntimeAgentConfig } from "./hostAdapter";
-
-type AgentRecord = Record<string, unknown>;
-
-function stringField(record: AgentRecord, key: string) {
-  const value = record[key];
-  return typeof value === "string" ? value : undefined;
-}
-
-function numberField(record: AgentRecord, key: string) {
-  const value = record[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function objectField(record: AgentRecord, key: string): Record<string, unknown> | undefined {
-  const value = record[key];
-  return value && typeof value === "object" && !Array.isArray(value)
-    ? value as Record<string, unknown>
-    : undefined;
-}
-
-function appendUniqueStrings(values: string[], next: unknown) {
-  if (!Array.isArray(next)) return values;
-  const seen = new Set(values);
-  for (const value of next) {
-    const toolName = typeof value === "string"
-      ? value
-      : value && typeof value === "object" && typeof (value as any).name === "string"
-        ? (value as any).name
-        : value && typeof value === "object" && typeof (value as any).function?.name === "string"
-          ? (value as any).function.name
-          : "";
-    if (toolName && !seen.has(toolName)) {
-      seen.add(toolName);
-      values.push(toolName);
-    }
-  }
-  return values;
-}
-
-function resolveAgentRuntimeToolNames(record: AgentRecord) {
-  const tools = appendUniqueStrings(
-    appendUniqueStrings([], record.toolNames),
-    record.tools,
-  );
-  return tools.length > 0 ? tools : undefined;
-}
-
-export function resolveAgentRuntimeConfigFromRecord(
-  key: string,
-  record: AgentRecord,
-): AgentRuntimeAgentConfig {
-  const name = stringField(record, "name");
-  const prompt = stringField(record, "prompt");
-  const model = stringField(record, "model");
-  const apiSource = stringField(record, "apiSource");
-  const cliProvider = stringField(record, "cliProvider");
-  const customProviderUrl = stringField(record, "customProviderUrl");
-  const apiKey = stringField(record, "apiKey");
-  const apiKeyHeader = stringField(record, "apiKeyHeader");
-  const apiKeyFromAgentKey = stringField(record, "apiKeyFromAgentKey");
-  const useServerProxy = record.useServerProxy === true;
-  const provider = stringField(record, "provider") ?? stringField(record, "apiSource");
-  const toolNames = resolveAgentRuntimeToolNames(record);
-  const temperature = numberField(record, "temperature");
-  const topP = numberField(record, "top_p");
-  const frequencyPenalty = numberField(record, "frequency_penalty");
-  const presencePenalty = numberField(record, "presence_penalty");
-  const maxTokens = numberField(record, "max_tokens");
-  const reasoningEffort = stringField(record, "reasoning_effort");
-  const runtimeBinding = objectField(record, "runtimeBinding");
-  const runtimeToolPolicy =
-    objectField(record, "runtimeToolPolicy") ??
-    objectField(runtimeBinding ?? {}, "runtimeToolPolicy");
-  const delegation = objectField(record, "delegation");
-  return {
-    key,
-    ...(name ? { name } : {}),
-    ...(prompt ? { prompt } : {}),
-    ...(model ? { model } : {}),
-    ...(provider ? { provider } : {}),
-    ...(apiSource ? { apiSource } : {}),
-    ...(cliProvider ? { cliProvider } : {}),
-    ...(customProviderUrl ? { customProviderUrl } : {}),
-    ...(apiKey ? { apiKey } : {}),
-    ...(apiKeyHeader ? { apiKeyHeader } : {}),
-    ...(apiKeyFromAgentKey ? { apiKeyFromAgentKey } : {}),
-    ...(useServerProxy ? { useServerProxy } : {}),
-    ...(toolNames ? { toolNames } : {}),
-    ...(temperature !== undefined ? { temperature } : {}),
-    ...(topP !== undefined ? { top_p: topP } : {}),
-    ...(frequencyPenalty !== undefined ? { frequency_penalty: frequencyPenalty } : {}),
-    ...(presencePenalty !== undefined ? { presence_penalty: presencePenalty } : {}),
-    ...(maxTokens !== undefined ? { max_tokens: maxTokens } : {}),
-    ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
-    ...(runtimeBinding ? { runtimeBinding } : {}),
-    ...(runtimeToolPolicy ? { runtimeToolPolicy } : {}),
-    ...(delegation ? { delegation } : {}),
-    rawRecord: record,
-  };
-}

package/agent-runtime/agentRecordKeys.ts

@@ -1,14 +0,0 @@
-export function buildAgentRuntimeAgentLookupKeys(args: {
-  agentRef: string;
-  userId: string;
-}) {
-  return [
-    args.agentRef,
-    `agent-${args.userId}-${args.agentRef}`,
-    `cybot-${args.userId}-${args.agentRef}`,
-  ];
-}
-
-export function shouldFetchAgentRuntimeRecordRemotely(dbKey: string) {
-  return /^(agent|cybot)(-pub)?-/.test(dbKey);
-}

package/agent-runtime/agentThread.ts

@@ -1,222 +0,0 @@
-export const AGENT_THREAD_RECORD_PREFIX = "agent-thread";
-export const AGENT_THREAD_INDEX_PREFIX = "agent-threadidx";
-
-export const AGENT_THREAD_STATUSES = [
-  "pending",
-  "running",
-  "done",
-  "failed",
-  "cancelled",
-] as const;
-
-export const AGENT_THREAD_ACTIVE_STATUSES = ["pending", "running"] as const;
-export const AGENT_THREAD_TERMINAL_STATUSES = ["done", "failed", "cancelled"] as const;
-
-export const AGENT_THREAD_KINDS = [
-  "chat",
-  "background",
-  "inline",
-  "handoff",
-  "parallel_branch",
-  "scheduled",
-] as const;
-
-export const AGENT_THREAD_PRESENTATION_INTENTS = [
-  "background_handoff",
-  "inline_result",
-  "handoff_speaker",
-  "parallel_branch",
-] as const;
-
-export type AgentThreadStatus = (typeof AGENT_THREAD_STATUSES)[number];
-export type AgentThreadActiveStatus =
-  (typeof AGENT_THREAD_ACTIVE_STATUSES)[number];
-export type AgentThreadTerminalStatus =
-  (typeof AGENT_THREAD_TERMINAL_STATUSES)[number];
-export type AgentThreadKind = (typeof AGENT_THREAD_KINDS)[number];
-export type AgentThreadPresentationIntent =
-  (typeof AGENT_THREAD_PRESENTATION_INTENTS)[number];
-
-export type AgentThreadListSection = "running" | "future" | "recent";
-
-export type AgentThreadSubjectRef = {
-  kind: string;
-  id: string;
-  role?: string;
-};
-
-export type AgentThreadSchedule =
-  | {
-      kind: "once";
-      timezone?: string;
-      nextRunAt: number;
-    }
-  | {
-      kind: "cron";
-      timezone?: string;
-      expression: string;
-      nextRunAt: number;
-    }
-  | {
-      kind: "interval";
-      timezone?: string;
-      everyMs: number;
-      nextRunAt: number;
-    };
-
-export type AgentThreadEvidence = {
-  kind: string;
-  summary?: string;
-  refs?: AgentThreadSubjectRef[];
-  data?: Record<string, unknown>;
-};
-
-export type AgentThreadRuntimeCheckpoint = {
-  status?: string;
-  toolCallCount?: number;
-  traceSummary?: unknown;
-  lastToolNames?: string[];
-  lastAssistantText?: string;
-  evidence?: AgentThreadEvidence[];
-  policyState?: unknown;
-  runtimeBinding?: unknown;
-  errorMessage?: string;
-};
-
-export type AgentThread = {
-  threadId: string;
-  title?: string;
-  summary?: string;
-
-  primaryAgentKey: string;
-  agentKeys: string[];
-  userId: string;
-
-  status: AgentThreadStatus;
-  threadKind: AgentThreadKind;
-  presentationIntent?: AgentThreadPresentationIntent;
-
-  parentThreadId?: string;
-  rootThreadId?: string;
-
-  dialogId?: string;
-  dialogKey?: string;
-
-  subjectRefs?: AgentThreadSubjectRef[];
-
-  schedule?: AgentThreadSchedule;
-  lastRunThreadId?: string;
-
-  createdAt: number;
-  updatedAt: number;
-  startedAt?: number;
-  finishedAt?: number;
-
-  runtimeCheckpoint?: AgentThreadRuntimeCheckpoint;
-};
-
-export function buildAgentThreadKey(args: {
-  userId: string;
-  threadId: string;
-}): string {
-  return [AGENT_THREAD_RECORD_PREFIX, args.userId, args.threadId].join("-");
-}
-
-export function buildAgentThreadUserRange(userId: string): {
-  gte: string;
-  lte: string;
-} {
-  const start = `${AGENT_THREAD_RECORD_PREFIX}-${userId}-`;
-  return { gte: start, lte: `${start}\uffff` };
-}
-
-export function buildAgentThreadByAgentStatusIndexKey(args: {
-  userId: string;
-  primaryAgentKey: string;
-  status: AgentThreadStatus;
-  threadId: string;
-}): string {
-  return [
-    AGENT_THREAD_INDEX_PREFIX,
-    args.userId,
-    "agent",
-    args.primaryAgentKey,
-    "status",
-    args.status,
-    args.threadId,
-  ].join("-");
-}
-
-export function buildAgentThreadByAgentStatusRange(args: {
-  userId: string;
-  primaryAgentKey: string;
-  status: AgentThreadStatus;
-}): {
-  gte: string;
-  lte: string;
-} {
-  const start = [
-    AGENT_THREAD_INDEX_PREFIX,
-    args.userId,
-    "agent",
-    args.primaryAgentKey,
-    "status",
-    args.status,
-    "",
-  ].join("-");
-  return { gte: start, lte: `${start}\uffff` };
-}
-
-export function isAgentThreadActiveStatus(
-  status: string | null | undefined,
-): status is AgentThreadActiveStatus {
-  return (AGENT_THREAD_ACTIVE_STATUSES as readonly string[]).includes(
-    status ?? "",
-  );
-}
-
-export function isAgentThreadTerminalStatus(
-  status: string | null | undefined,
-): status is AgentThreadTerminalStatus {
-  return (AGENT_THREAD_TERMINAL_STATUSES as readonly string[]).includes(
-    status ?? "",
-  );
-}
-
-export function isFutureAgentThread(
-  thread: Pick<AgentThread, "schedule" | "status">,
-  nowMs: number,
-): boolean {
-  return (
-    isAgentThreadActiveStatus(thread.status) &&
-    typeof thread.schedule?.nextRunAt === "number" &&
-    thread.schedule.nextRunAt > nowMs
-  );
-}
-
-export function getAgentThreadListSection(
-  thread: Pick<AgentThread, "schedule" | "status">,
-  nowMs: number,
-): AgentThreadListSection {
-  if (isFutureAgentThread(thread, nowMs)) return "future";
-  if (isAgentThreadActiveStatus(thread.status)) return "running";
-  return "recent";
-}
-
-export function getAgentThreadRootId(
-  thread: Pick<AgentThread, "threadId" | "parentThreadId" | "rootThreadId">,
-): string {
-  return thread.rootThreadId || thread.parentThreadId || thread.threadId;
-}
-
-export function buildChildAgentThreadRelations(
-  parent: Pick<AgentThread, "threadId" | "rootThreadId">,
-): {
-  parentThreadId: string;
-  rootThreadId: string;
-} {
-  return {
-    parentThreadId: parent.threadId,
-    rootThreadId: parent.rootThreadId || parent.threadId,
-  };
-}

package/agent-runtime/agentThreadAdmission.ts

@@ -1,74 +0,0 @@
-/**
- * Default maxConcurrent used when an agent has no admission config.
- * v0 policy: hard-coded to 2 until per-agent config is widely adopted.
- */
-export const DEFAULT_AGENT_THREAD_MAX_CONCURRENT = 2;
-
-export type AgentThreadAdmissionConfig = {
-  maxConcurrent?: unknown;
-};
-
-export type AgentThreadAdmissionAgentConfig = {
-  maxConcurrent?: unknown;
-  admission?: AgentThreadAdmissionConfig | null;
-} | null | undefined;
-
-export type AgentThreadAdmissionDecision =
-  | {
-      allowed: true;
-      activeThreadCount: number;
-      maxConcurrent: number;
-    }
-  | {
-      allowed: false;
-      reason: "max_concurrent_reached";
-      activeThreadCount: number;
-      maxConcurrent: number;
-    };
-
-export function normalizeAgentThreadMaxConcurrent(value: unknown): number | null {
-  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-    return null;
-  }
-  return value;
-}
-
-export function resolveAgentThreadMaxConcurrent(
-  agentConfig: AgentThreadAdmissionAgentConfig,
-): number | null {
-  const nestedLimit = normalizeAgentThreadMaxConcurrent(
-    agentConfig?.admission?.maxConcurrent,
-  );
-  if (nestedLimit != null) return nestedLimit;
-  return normalizeAgentThreadMaxConcurrent(agentConfig?.maxConcurrent);
-}
-
-export function decideAgentThreadAdmission(input: {
-  agentConfig: AgentThreadAdmissionAgentConfig;
-  activeThreadCount: number;
-}): AgentThreadAdmissionDecision {
-  const activeThreadCount =
-    typeof input.activeThreadCount === "number" &&
-    Number.isFinite(input.activeThreadCount) &&
-    input.activeThreadCount > 0
-      ? Math.floor(input.activeThreadCount)
-      : 0;
-  const maxConcurrent =
-    resolveAgentThreadMaxConcurrent(input.agentConfig) ??
-    DEFAULT_AGENT_THREAD_MAX_CONCURRENT;
-
-  if (activeThreadCount < maxConcurrent) {
-    return {
-      allowed: true,
-      activeThreadCount,
-      maxConcurrent,
-    };
-  }
-
-  return {
-    allowed: false,
-    reason: "max_concurrent_reached",
-    activeThreadCount,
-    maxConcurrent,
-  };
-}

package/agent-runtime/dialogMessageRecord.ts

@@ -1,16 +0,0 @@
-import type { AgentRuntimeChatMessage } from "./types";
-
-type DialogMessageRecord = Record<string, any>;
-
-export function dialogMessageRecordToAgentRuntimeMessage(
-  record: DialogMessageRecord
-): AgentRuntimeChatMessage | null {
-  if (!record || typeof record !== "object") return null;
-  if (record.role !== "user" && record.role !== "assistant" && record.role !== "tool") return null;
-  return {
-    role: record.role,
-    content: record.content ?? null,
-    ...(typeof record.toolCallId === "string" ? { tool_call_id: record.toolCallId } : {}),
-    ...(Array.isArray(record.tool_calls) ? { tool_calls: record.tool_calls } : {}),
-  };
-}

package/agent-runtime/dialogWritePlan.ts

@@ -1,211 +0,0 @@
-import type {
-  AgentRuntimeChatMessage,
-  AgentRuntimeHost,
-} from "./types";
-import type { AgentRuntimeSaveTurnInput } from "./hostAdapter";
-
-type DialogRecord = Record<string, any>;
-type DialogWriteOp = {
-  type: "put";
-  key: string;
-  value: DialogRecord;
-};
-type DialogSubjectRef = {
-  kind: string;
-  id: string;
-  role?: string;
-};
-
-function extractLastUserText(messages: AgentRuntimeChatMessage[]) {
-  const lastUser = [...messages].reverse().find((message) => message.role === "user");
-  if (typeof lastUser?.content === "string") return lastUser.content;
-  if (Array.isArray(lastUser?.content)) {
-    return lastUser.content
-      .filter((part) => part.type === "text")
-      .map((part) => part.text)
-      .join(" ");
-  }
-  return "";
-}
-
-function resolveDialogTitle(args: {
-  existingDialog?: DialogRecord | null;
-  messages: AgentRuntimeChatMessage[];
-}) {
-  if (typeof args.existingDialog?.title === "string" && args.existingDialog.title.trim()) {
-    return args.existingDialog.title;
-  }
-  const lastUserText = extractLastUserText(args.messages).trim();
-  return lastUserText ? lastUserText.slice(0, 80) : "Local agent run";
-}
-
-function normalizeNonEmptyString(value: unknown) {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-
-function normalizeSubjectRef(ref: unknown): DialogSubjectRef | null {
-  if (!ref || typeof ref !== "object") return null;
-  const raw = ref as Record<string, unknown>;
-  const kind = normalizeNonEmptyString(raw.kind);
-  const id = normalizeNonEmptyString(raw.id);
-  if (!kind || !id) return null;
-  const role = normalizeNonEmptyString(raw.role);
-  return {
-    kind,
-    id,
-    ...(role ? { role } : {}),
-  };
-}
-
-function mergeSubjectRefs(...groups: unknown[]): DialogSubjectRef[] | undefined {
-  const refs: DialogSubjectRef[] = [];
-  const seen = new Set<string>();
-  for (const group of groups) {
-    if (!Array.isArray(group)) continue;
-    for (const item of group) {
-      const ref = normalizeSubjectRef(item);
-      if (!ref) continue;
-      const key = `${ref.kind}:${ref.id}:${ref.role ?? ""}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      refs.push(ref);
-    }
-  }
-  return refs.length ? refs : undefined;
-}
-
-function buildRuntimeSubjectRefs(runtimeContext?: Record<string, any> | null): DialogSubjectRef[] | undefined {
-  return mergeSubjectRefs(runtimeContext?.subjectRefs);
-}
-
-function buildDialogLineageFields(args: {
-  input: AgentRuntimeSaveTurnInput;
-  existingDialog?: DialogRecord | null;
-}) {
-  const inheritedFromDialogKey = normalizeNonEmptyString(args.input.inheritedFromDialogKey);
-  const parentDialogId = normalizeNonEmptyString(args.input.parentDialogId);
-  if (!inheritedFromDialogKey && !parentDialogId) return {};
-  const rootDialogId =
-    normalizeNonEmptyString(args.existingDialog?.rootDialogId) ??
-    normalizeNonEmptyString(args.existingDialog?.parentDialogId) ??
-    parentDialogId;
-  return {
-    ...(inheritedFromDialogKey ? { inheritedFromDialogKey } : {}),
-    ...(parentDialogId ? { parentDialogId } : {}),
-    ...(rootDialogId ? { rootDialogId } : {}),
-  };
-}
-
-function buildDialogMessageWriteOps(args: {
-  dialogId: string;
-  input: AgentRuntimeSaveTurnInput;
-  userId: string;
-  now: number;
-  nowIso: string;
-}): DialogWriteOp[] {
-  return args.input.messages
-    .filter((message) => message.role !== "system")
-    .map((message, index) => {
-      // Keep timestamp-prefix ordering for LevelDB range scans. Do not switch
-      // to opaque ids until dialog query/continuation callers are reviewed.
-      const id = `${args.now}-${String(index + 1).padStart(3, "0")}`;
-      const key = `dialog-${args.dialogId}-msg-${id}`;
-      return {
-        type: "put" as const,
-        key,
-        value: {
-          id,
-          dbKey: key,
-          dialogId: args.dialogId,
-          role: message.role,
-          content: message.content ?? "",
-          ...(message.role === "user" ? { userId: args.userId } : {}),
-          ...(message.role === "assistant" ? {
-            agentKey: args.input.agentKey,
-            cybotKey: args.input.agentKey,
-          } : {}),
-          ...(message.tool_call_id ? { toolCallId: message.tool_call_id } : {}),
-          ...(Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {}),
-          ...(message.tool_result_metadata ? { metadata: message.tool_result_metadata } : {}),
-          createdAt: args.nowIso,
-        },
-      };
-    });
-}
-
-export function buildAgentRuntimeDialogWritePlan(args: {
-  input: AgentRuntimeSaveTurnInput;
-  userId: string;
-  now: number;
-  createId: () => string;
-  runtimeHost: AgentRuntimeHost;
-  runtimeMetadata?: Record<string, unknown>;
-  existingDialog?: DialogRecord | null;
-}): { dialogId: string; ops: DialogWriteOp[] } {
-  const dialogId = args.input.continueDialogId || args.createId();
-  const nowIso = new Date(args.now).toISOString();
-  const dialogKey = `dialog-${args.userId}-${dialogId}`;
-  const subjectRefs = buildRuntimeSubjectRefs(args.input.runtimeContext);
-  const dialogRecord = {
-    ...(args.existingDialog && typeof args.existingDialog === "object" ? args.existingDialog : {}),
-    id: dialogId,
-    dbKey: dialogKey,
-    type: "dialog",
-    userId: args.userId,
-    cybots: [args.input.agentKey],
-    primaryAgentKey: args.input.agentKey,
-    title: resolveDialogTitle({
-      existingDialog: args.existingDialog,
-      messages: args.input.messages,
-    }),
-    status: "done",
-    triggerType: `${args.runtimeHost}-local`,
-    executionMode: "foreground",
-    createdAt: args.existingDialog?.createdAt ?? nowIso,
-    updatedAt: nowIso,
-    finishedAt: args.now,
-    usage: args.input.result.usage,
-    ...(normalizeNonEmptyString(args.input.spaceId) ? { spaceId: normalizeNonEmptyString(args.input.spaceId) } : {}),
-    ...(normalizeNonEmptyString(args.input.category) ? { category: normalizeNonEmptyString(args.input.category) } : {}),
-    ...(subjectRefs ? { subjectRefs } : {}),
-    ...buildDialogLineageFields({
-      input: args.input,
-      existingDialog: args.existingDialog,
-    }),
-    ...(typeof args.input.result.toolCallCount === "number"
-      ? { toolCallCount: args.input.result.toolCallCount }
-      : {}),
-    localRuntime: {
-      host: args.runtimeHost,
-      ...(args.runtimeMetadata ?? {}),
-    },
-    ...(args.input.result.runtimeToolSurface
-      ? {
-          runtimeCheckpoint: {
-            ...(args.existingDialog?.runtimeCheckpoint &&
-            typeof args.existingDialog.runtimeCheckpoint === "object"
-              ? args.existingDialog.runtimeCheckpoint
-              : {}),
-            toolSurface: args.input.result.runtimeToolSurface,
-          },
-        }
-      : {}),
-  };
-  return {
-    dialogId,
-    ops: [
-      {
-        type: "put",
-        key: dialogKey,
-        value: dialogRecord,
-      },
-      ...buildDialogMessageWriteOps({
-        dialogId,
-        input: args.input,
-        userId: args.userId,
-        now: args.now,
-        nowIso,
-      }),
-    ],
-  };
-}