tinker-agent 1.10.1 → 2.0.0

package/src/session/session-store.ts

@@ -32,7 +32,6 @@ import {
   MODEL_MESSAGE_PROTOCOL_ADAPTERS,
   type ModelMessageProtocol,
 } from "../model/model-client";
-import type { InputTokenEstimatorCompatibility } from "../model/input-token-estimator";
 import type { ToolDefinition, ToolRawResult } from "../tools/types";
 import { sha256, stableJsonStringify } from "../model/model-request-preflight";
 import {
@@ -149,7 +148,16 @@ export type SessionImageInputCompatibility = {
   readonly policyVersion: string;
   readonly policySha256: string;
   readonly inputModalities: readonly ("text" | "image")[];
-  readonly tokenEstimator?: InputTokenEstimatorCompatibility;
+  readonly tokenEstimator?: LegacyInputTokenEstimatorCompatibility;
+};
+
+type LegacyInputTokenEstimatorCompatibility = {
+  readonly kind: "moonshot-estimate-token-count-v1";
+  readonly coverageVersion: "full-request-v1";
+  readonly model: string;
+  readonly endpoint: string;
+  readonly timeoutMs: number;
+  readonly maxRetries: 0;
 };
 
 export type CompletedTurnMessageSnapshot =
@@ -660,6 +668,9 @@ export class SessionStore implements SessionLedgerCommitter {
           case "begin_turn":
             this.commitBeginTurn(mutation, now);
             break;
+          case "append_steering_users":
+            this.commitSteeringUsers(mutation, now);
+            break;
           case "append_assistant":
             this.commitAssistant(mutation, now);
             break;
@@ -2848,6 +2859,32 @@ export class SessionStore implements SessionLedgerCommitter {
     requireSingleChange(this.database, updated.changes, "advance turn counter");
   }
 
+  private commitSteeringUsers(
+    mutation: Extract<LedgerMutation, { kind: "append_steering_users" }>,
+    now: string,
+  ): void {
+    const turn = this.requireTurnRow(mutation.turn.turnId);
+    if (turn.status !== "open") {
+      throw new Error(`Turn ${mutation.turn.turnId} is not open.`);
+    }
+    if (
+      mutation.frames.length === 0 ||
+      mutation.frames.length !== mutation.messages.length
+    ) {
+      throw new Error(
+        "Steering user mutation must contain matching frames and messages.",
+      );
+    }
+    for (let index = 0; index < mutation.frames.length; index += 1) {
+      insertFrame(this.database, requireItem(mutation.frames, index, "steering frame"));
+      insertMessage(
+        this.database,
+        requireItem(mutation.messages, index, "steering message"),
+      );
+    }
+    this.touch(now);
+  }
+
   private commitAssistant(
     mutation: Extract<LedgerMutation, { kind: "append_assistant" }>,
     now: string,
@@ -3675,7 +3712,6 @@ export function createSessionCompatibilityContract(input: {
   contextProfile: ModelContextProfile;
   messageProtocol: ModelMessageProtocol;
   inputModalities?: readonly ("text" | "image")[];
-  tokenEstimator?: InputTokenEstimatorCompatibility;
 }): SessionCompatibilityContract {
   if (input.modelName.trim() === "") {
     throw new Error("Session compatibility model name must not be empty.");
@@ -3693,14 +3729,6 @@ export function createSessionCompatibilityContract(input: {
     throw new Error("Session compatibility message protocol is invalid.");
   }
   const inputModalities = normalizeInputModalities(input.inputModalities ?? ["text"]);
-  if (inputModalities.includes("image") && input.tokenEstimator === undefined) {
-    throw new Error(
-      "Session compatibility image input requires a token estimator identity.",
-    );
-  }
-  if (input.tokenEstimator !== undefined) {
-    validateTokenEstimatorCompatibility(input.tokenEstimator);
-  }
   return Object.freeze({
     modelName: input.modelName,
     ...(input.profileName === undefined ? {} : { profileName: input.profileName }),
@@ -3716,9 +3744,6 @@ export function createSessionCompatibilityContract(input: {
         }),
       ),
       inputModalities,
-      ...(input.tokenEstimator === undefined
-        ? {}
-        : { tokenEstimator: immutableCanonicalClone(input.tokenEstimator) }),
     }),
   });
 }
@@ -3735,9 +3760,6 @@ function normalizeSessionCompatibilityContract(
     contextProfile: contract.contextProfile,
     messageProtocol: contract.messageProtocol,
     inputModalities: contract.imageInput.inputModalities,
-    ...(contract.imageInput.tokenEstimator === undefined
-      ? {}
-      : { tokenEstimator: contract.imageInput.tokenEstimator }),
   });
 }
 
@@ -3758,7 +3780,7 @@ function normalizeInputModalities(
 }
 
 function validateTokenEstimatorCompatibility(
-  estimator: InputTokenEstimatorCompatibility,
+  estimator: LegacyInputTokenEstimatorCompatibility,
 ): void {
   if (
     estimator.kind !== "moonshot-estimate-token-count-v1" ||
@@ -5565,9 +5587,6 @@ function decodeSessionCompatibilityContract(
       enumFromSql(value, ["text", "image"] as const, "compatibility input modality"),
     ),
   );
-  if (modalities.includes("image") && tokenEstimator === undefined) {
-    throw new Error("Stored image input compatibility has no token estimator.");
-  }
   const policyVersion = stringFromSql(
     imageInput.policyVersion,
     "compatibility image policyVersion",
@@ -5596,7 +5615,7 @@ function decodeSessionCompatibilityContract(
 
 function decodeTokenEstimatorCompatibility(
   value: unknown,
-): InputTokenEstimatorCompatibility {
+): LegacyInputTokenEstimatorCompatibility {
   const record = recordFromSql(value, "session compatibility token estimator");
   assertObjectKeys(
     record,
@@ -5604,7 +5623,7 @@ function decodeTokenEstimatorCompatibility(
     ["kind", "coverageVersion", "model", "endpoint", "timeoutMs", "maxRetries"],
     "session compatibility token estimator",
   );
-  const estimator: InputTokenEstimatorCompatibility = {
+  const estimator: LegacyInputTokenEstimatorCompatibility = {
     kind: enumFromSql(
       record.kind,
       ["moonshot-estimate-token-count-v1"] as const,

package/src/tui/app.tsx

@@ -108,6 +108,10 @@ const STATIC_HEADER = Symbol("tui-static-header");
 const LIVE_TIMELINE_MAX_ROWS = 8;
 const LIVE_TIMELINE_WITH_TASKS_MAX_ROWS = 3;
 const BACKGROUND_TASKS_MAX_ROWS = 12;
+const IDLE_PROMPT_SCHEDULER = Object.freeze({
+  state: "idle" as const,
+  pendingCount: 0,
+});
 
 export function App(props: AppProps) {
   const { exit } = useApp();
@@ -137,11 +141,23 @@ export function App(props: AppProps) {
     () => binding.bashGuard(),
     () => binding.bashGuard(),
   );
+  const promptScheduler = useSyncExternalStore(
+    (listener) => binding.subscribePromptScheduler?.(listener) ?? (() => undefined),
+    () => binding.promptScheduler?.() ?? IDLE_PROMPT_SCHEDULER,
+    () => binding.promptScheduler?.() ?? IDLE_PROMPT_SCHEDULER,
+  );
   const [isRunning, setIsRunning] = useState(false);
+  const executionRunning = isRunning || promptScheduler.state === "running";
   const [isSessionOperation, setIsSessionOperation] = useState(false);
   const [isCopying, setIsCopying] = useState(false);
   const [isCancelling, setIsCancelling] = useState(false);
   const [notice, setNotice] = useState<string | undefined>(props.initialNotice);
+  const currentQueuedFollowUpNotice = `Follow-up queued for the active turn (${promptScheduler.pendingCount} pending).`;
+  const visibleNotice =
+    notice?.startsWith("Follow-up queued for the active turn (") === true &&
+    notice !== currentQueuedFollowUpNotice
+      ? undefined
+      : notice;
   const [showStatus, setShowStatus] = useState(false);
   const [showSkills, setShowSkills] = useState(false);
   const [showMcp, setShowMcp] = useState(false);
@@ -259,7 +275,7 @@ export function App(props: AppProps) {
       setIsCancelling(true);
       setNotice("Cancelling current turn...");
     },
-    { isActive: isRunning },
+    { isActive: executionRunning },
   );
 
   const closeResumePicker = () => {
@@ -449,6 +465,32 @@ export function App(props: AppProps) {
     submission: PromptSubmission,
     admissionSignal: AbortSignal,
   ): Promise<PromptSubmissionOutcome> => {
+    if (promptScheduler.state === "running") {
+      if (submission.userMessage.attachments !== undefined) {
+        setNotice("Active-turn follow-ups do not support image attachments.");
+        return false;
+      }
+      if (submission.userMessage.content.trimStart().startsWith("/")) {
+        setNotice("Slash commands cannot be queued while a turn is running.");
+        return false;
+      }
+      try {
+        const queued = binding.queueFollowUp?.(submission.userMessage);
+        if (queued === undefined) {
+          throw new Error("TUI session binding does not support follow-up queuing.");
+        }
+        void props.history?.append(submission.draft).catch((error: unknown) => {
+          setNotice(`Prompt history write failed: ${errorMessage(error)}`);
+        });
+        setNotice(
+          `Follow-up queued for the active turn (${queued.pendingCount} pending).`,
+        );
+        return true;
+      } catch (error) {
+        setNotice(`Follow-up was not queued: ${errorMessage(error)}`);
+        return false;
+      }
+    }
     if (isRunning) return false;
     setNotice(undefined);
     setIsCancelling(false);
@@ -557,6 +599,10 @@ export function App(props: AppProps) {
       restoreStaticViewport();
     }
 
+    if (promptScheduler.state === "running") {
+      return submitAgentPrompt(submission, signal);
+    }
+
     if (userMessage.attachments === undefined && trimmed.startsWith("/")) {
       try {
         const projectCommand = resolveProjectSlashCommand(
@@ -856,9 +902,16 @@ export function App(props: AppProps) {
             </Box>
             <Box marginTop={1} flexShrink={0}>
               <Footer
-                status={isCancelling ? "cancelling" : state.status}
+                status={
+                  isCancelling
+                    ? "cancelling"
+                    : executionRunning
+                      ? "running"
+                      : state.status
+                }
                 workedForMs={state.workedForMs}
                 yolo={bashGuard.mode === "yolo"}
+                pendingFollowUps={promptScheduler.pendingCount}
               />
             </Box>
             <Box marginTop={1} flexDirection="column" flexShrink={0}>
@@ -891,26 +944,38 @@ export function App(props: AppProps) {
                   gitBranch={gitBranch}
                   contextUsage={state.contextUsage}
                   isDisabled={
-                    isRunning ||
                     isSessionOperation ||
                     isCopying ||
+                    isCancelling ||
                     bashGuard.pending !== undefined
                   }
                   history={props.history}
                   commands={availableCommands}
                   fileLister={props.fileLister}
-                  importImage={binding.importImage}
+                  importImage={
+                    promptScheduler.state === "running"
+                      ? undefined
+                      : binding.importImage
+                  }
                   verifyImageAssets={binding.verifyImageAssets}
                   onCycleReasoningEffort={
-                    hasReasoningEffort ? cycleReasoningEffort : undefined
+                    hasReasoningEffort && promptScheduler.state !== "running"
+                      ? cycleReasoningEffort
+                      : undefined
                   }
                   onSubmit={onSubmit}
                   onMaintenance={onMaintenance}
-                  placeholder='Enter a coding request, or "/" for commands'
+                  placeholder={
+                    promptScheduler.state === "running"
+                      ? "Send a follow-up for the active turn…"
+                      : 'Enter a coding request, or "/" for commands'
+                  }
                 />
               )}
               {viewError === undefined ? null : <Text color="red">{viewError}</Text>}
-              {notice === undefined ? null : <Text color="yellow">{notice}</Text>}
+              {visibleNotice === undefined ? null : (
+                <Text color="yellow">{visibleNotice}</Text>
+              )}
             </Box>
           </Box>
         )}

package/src/tui/components/footer.tsx

@@ -4,6 +4,7 @@ export type FooterProps = {
   status: "idle" | "running" | "cancelling" | "cancelled" | "done" | "failed";
   workedForMs?: number;
   yolo?: boolean;
+  pendingFollowUps?: number;
 };
 
 export function Footer(props: FooterProps) {
@@ -26,7 +27,11 @@ export function Footer(props: FooterProps) {
   }
 
   if (props.status === "running") {
-    return <Spinner label={`Running${suffix}`} />;
+    const queued =
+      props.pendingFollowUps === undefined || props.pendingFollowUps === 0
+        ? ""
+        : ` · ${props.pendingFollowUps} follow-up${props.pendingFollowUps === 1 ? "" : "s"} queued`;
+    return <Spinner label={`Running${queued}${suffix}`} />;
   }
 
   if (props.status === "cancelling") {

package/src/tui/event-store.ts

@@ -155,6 +155,21 @@ export function reduceTuiProjection(
         },
       };
     }
+    case "turn.steering.applied": {
+      const userPrompt = truncateUserPromptProjection(
+        event.data.userPrompt,
+        MAX_TIMELINE_PROMPT_CODE_POINTS,
+      );
+      return updateActiveTurn(state, event, policy, (turn) =>
+        appendTurnItem(turn, {
+          id: `turn-${event.turnId}-steering-${event.eventSequence}`,
+          label: "follow-up",
+          text: userPrompt.text,
+          userPrompt,
+          status: "text",
+        }),
+      );
+    }
     case "model.request.started":
       return updateActiveTurn(state, event, policy, (turn) =>
         event.data.attemptNumber === 1

package/src/tui/tui-session-controller.ts

@@ -45,6 +45,9 @@ export type TuiSessionBinding = {
   ) => Promise<void>;
   admitTurn?: (userMessage: UserMessage, signal: AbortSignal) => Promise<AcceptedTurn>;
   executeTurn(userMessage: UserMessage, signal: AbortSignal): Promise<RunAgentResult>;
+  promptScheduler?: RuntimeSession["promptScheduler"];
+  subscribePromptScheduler?: RuntimeSession["subscribePromptScheduler"];
+  queueFollowUp?: RuntimeSession["queueFollowUp"];
   bashGuard(): BashGuardSnapshot;
   subscribeBashGuard(listener: () => void): () => void;
   setYoloMode(enabled: boolean): void;
@@ -250,6 +253,10 @@ export function managedTuiBinding(input: {
         userMessage,
         signal,
       } satisfies ExecuteTurnInput),
+    promptScheduler: () => input.runtimeSession.promptScheduler(),
+    subscribePromptScheduler: (listener) =>
+      input.runtimeSession.subscribePromptScheduler(listener),
+    queueFollowUp: (userMessage) => input.runtimeSession.queueFollowUp(userMessage),
     bashGuard: () => input.runtimeSession.bashGuard(),
     subscribeBashGuard: (listener) => input.runtimeSession.subscribeBashGuard(listener),
     setYoloMode: (enabled) => input.runtimeSession.setYoloMode(enabled),

package/src/model/input-token-estimator.ts

@@ -1,25 +0,0 @@
-import type { MaterializedModelRequest } from "./model-client";
-
-export type InputTokenEstimate = {
-  readonly inputTokens: number;
-  readonly source: "provider_estimated";
-  readonly coverage: "messages" | "full_request";
-};
-
-export type InputTokenEstimatorCompatibility = {
-  readonly kind: "moonshot-estimate-token-count-v1";
-  readonly coverageVersion: "full-request-v1";
-  readonly model: string;
-  readonly endpoint: string;
-  readonly timeoutMs: number;
-  readonly maxRetries: 0;
-};
-
-export interface InputTokenEstimator {
-  readonly kind: string;
-  readonly compatibility: InputTokenEstimatorCompatibility;
-  estimate(
-    request: MaterializedModelRequest,
-    options: { signal: AbortSignal },
-  ): Promise<InputTokenEstimate>;
-}

package/src/model/moonshot-input-token-estimator.ts

@@ -1,111 +0,0 @@
-import type { InputTokenEstimate, InputTokenEstimator } from "./input-token-estimator";
-import type { MaterializedModelRequest } from "./model-client";
-import { IMAGE_INPUT_POLICY } from "../image/image-input-policy";
-
-export class MoonshotInputTokenEstimator implements InputTokenEstimator {
-  readonly kind = "moonshot-estimate-token-count-v1";
-  readonly compatibility: InputTokenEstimator["compatibility"];
-  private readonly endpoint: string;
-
-  constructor(
-    private readonly options: {
-      apiKey: string;
-      baseURL: string;
-      model: string;
-      timeoutMs: number;
-      fetch?: typeof fetch;
-      payloadMapper?: (payload: unknown) => unknown;
-    },
-  ) {
-    const base = new URL(
-      options.baseURL.endsWith("/") ? options.baseURL : `${options.baseURL}/`,
-    );
-    base.username = "";
-    base.password = "";
-    base.search = "";
-    base.hash = "";
-    const endpoint = new URL("tokenizers/estimate-token-count", base);
-    this.endpoint = endpoint.toString();
-    this.compatibility = Object.freeze({
-      kind: "moonshot-estimate-token-count-v1",
-      coverageVersion: "full-request-v1",
-      model: options.model,
-      endpoint: this.endpoint,
-      timeoutMs: options.timeoutMs,
-      maxRetries: 0,
-    });
-  }
-
-  async estimate(
-    request: MaterializedModelRequest,
-    options: { signal: AbortSignal },
-  ): Promise<InputTokenEstimate> {
-    const chatPayload = requireRecord(
-      this.options.payloadMapper?.(request.payload) ?? request.payload,
-      "materialized chat payload",
-    );
-    if (!Array.isArray(chatPayload.messages)) {
-      throw new Error("Materialized request has no token estimator messages.");
-    }
-    const payload = {
-      model: this.options.model,
-      messages: chatPayload.messages,
-      ...(Array.isArray(chatPayload.tools) ? { tools: chatPayload.tools } : {}),
-    };
-    const body = JSON.stringify(payload);
-    const bodyBytes = Buffer.byteLength(body, "utf8");
-    if (bodyBytes > IMAGE_INPUT_POLICY.maxRequestBodyBytes) {
-      throw new Error(
-        `Token estimate request is ${bodyBytes} bytes; maximum is ${IMAGE_INPUT_POLICY.maxRequestBodyBytes}.`,
-      );
-    }
-
-    const controller = new AbortController();
-    const timeout = setTimeout(
-      () => controller.abort(new Error("Token estimate timed out.")),
-      this.options.timeoutMs,
-    );
-    const onAbort = () => controller.abort(options.signal.reason);
-    options.signal.addEventListener("abort", onAbort, { once: true });
-    try {
-      options.signal.throwIfAborted();
-      const response = await (this.options.fetch ?? fetch)(this.endpoint, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${this.options.apiKey}`,
-          "content-type": "application/json",
-        },
-        body,
-        signal: controller.signal,
-      });
-      if (!response.ok) {
-        throw new Error(`Token estimate endpoint returned HTTP ${response.status}.`);
-      }
-      const decoded: unknown = await response.json();
-      const root = requireRecord(decoded, "token estimate response");
-      if (root.error !== undefined && root.error !== null) {
-        throw new Error("Token estimate endpoint returned an error response.");
-      }
-      const data = requireRecord(root.data, "token estimate response data");
-      const inputTokens = data.total_tokens;
-      if (!Number.isSafeInteger(inputTokens) || (inputTokens as number) < 0) {
-        throw new Error("Token estimate response total_tokens is invalid.");
-      }
-      return Object.freeze({
-        inputTokens: inputTokens as number,
-        source: "provider_estimated",
-        coverage: "full_request",
-      });
-    } finally {
-      clearTimeout(timeout);
-      options.signal.removeEventListener("abort", onAbort);
-    }
-  }
-}
-
-function requireRecord(value: unknown, name: string): Record<string, unknown> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error(`${name} must be an object.`);
-  }
-  return value as Record<string, unknown>;
-}

package/src/model/openai-responses-token-estimator.ts

@@ -1,155 +0,0 @@
-type ChatEstimatorToolCall = {
-  id: string;
-  type: "function";
-  function: {
-    name: string;
-    arguments: string;
-  };
-};
-
-type ChatEstimatorMessage = {
-  role: "system" | "user" | "assistant" | "tool";
-  content: unknown;
-  tool_calls?: ChatEstimatorToolCall[];
-  tool_call_id?: string;
-};
-
-export function responsesPayloadForChatTokenEstimator(
-  payload: unknown,
-): Record<string, unknown> {
-  const root = requireRecord(payload, "Responses token estimator payload");
-  if (!Array.isArray(root.input)) {
-    throw new Error("Responses token estimator payload input must be an array.");
-  }
-
-  const messages: ChatEstimatorMessage[] = [];
-  for (const [index, rawItem] of root.input.entries()) {
-    const path = `Responses token estimator input[${index}]`;
-    const item = requireRecord(rawItem, path);
-    const type = requireString(item.type, `${path}.type`);
-    if (type === "message") {
-      messages.push(toChatMessage(item, path));
-      continue;
-    }
-    if (type === "function_call") {
-      appendFunctionCall(messages, item, path);
-      continue;
-    }
-    if (type === "function_call_output") {
-      messages.push({
-        role: "tool",
-        tool_call_id: requireString(item.call_id, `${path}.call_id`),
-        content: requireString(item.output, `${path}.output`),
-      });
-      continue;
-    }
-    throw new Error(`${path}.type is unsupported: ${JSON.stringify(type)}.`);
-  }
-
-  return {
-    messages,
-    ...(root.tools === undefined ? {} : { tools: toChatTools(root.tools) }),
-  };
-}
-
-function toChatMessage(
-  item: Record<string, unknown>,
-  path: string,
-): ChatEstimatorMessage {
-  const role = requireString(item.role, `${path}.role`);
-  if (role !== "system" && role !== "user" && role !== "assistant") {
-    throw new Error(`${path}.role is unsupported: ${JSON.stringify(role)}.`);
-  }
-  return {
-    role,
-    content: toChatContent(item.content, `${path}.content`),
-  };
-}
-
-function toChatContent(value: unknown, path: string): unknown {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (!Array.isArray(value)) {
-    throw new Error(`${path} must be a string or an array.`);
-  }
-  return value.map((rawPart, index) => {
-    const partPath = `${path}[${index}]`;
-    const part = requireRecord(rawPart, partPath);
-    const type = requireString(part.type, `${partPath}.type`);
-    if (type === "input_text") {
-      return {
-        type: "text",
-        text: requireString(part.text, `${partPath}.text`),
-      };
-    }
-    if (type === "input_image") {
-      return {
-        type: "image_url",
-        image_url: {
-          url: requireString(part.image_url, `${partPath}.image_url`),
-          ...(part.detail === undefined
-            ? {}
-            : { detail: requireString(part.detail, `${partPath}.detail`) }),
-        },
-      };
-    }
-    throw new Error(`${partPath}.type is unsupported: ${JSON.stringify(type)}.`);
-  });
-}
-
-function appendFunctionCall(
-  messages: ChatEstimatorMessage[],
-  item: Record<string, unknown>,
-  path: string,
-): void {
-  const call: ChatEstimatorToolCall = {
-    id: requireString(item.call_id, `${path}.call_id`),
-    type: "function",
-    function: {
-      name: requireString(item.name, `${path}.name`),
-      arguments: requireString(item.arguments, `${path}.arguments`),
-    },
-  };
-  const previous = messages[messages.length - 1];
-  if (previous?.role === "assistant") {
-    (previous.tool_calls ??= []).push(call);
-    return;
-  }
-  messages.push({ role: "assistant", content: null, tool_calls: [call] });
-}
-
-function toChatTools(value: unknown): Record<string, unknown>[] {
-  if (!Array.isArray(value)) {
-    throw new Error("Responses token estimator payload tools must be an array.");
-  }
-  return value.map((rawTool, index) => {
-    const path = `Responses token estimator tools[${index}]`;
-    const tool = requireRecord(rawTool, path);
-    if (tool.type !== "function") {
-      throw new Error(`${path}.type must be "function".`);
-    }
-    return {
-      type: "function",
-      function: {
-        name: requireString(tool.name, `${path}.name`),
-        description: requireString(tool.description, `${path}.description`),
-        parameters: requireRecord(tool.parameters, `${path}.parameters`),
-      },
-    };
-  });
-}
-
-function requireRecord(value: unknown, path: string): Record<string, unknown> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error(`${path} must be an object.`);
-  }
-  return value as Record<string, unknown>;
-}
-
-function requireString(value: unknown, path: string): string {
-  if (typeof value !== "string") {
-    throw new Error(`${path} must be a string.`);
-  }
-  return value;
-}