nolo-cli 0.32.0 → 0.33.0-alpha.3

package/{chunk-WHLVPK32.js → chunk-KMSZPTM6.js}

@@ -1,12 +1,12 @@
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";
-import {
-  asTrimmedString
-} from "./chunk-3EUW3WEO.js";
 import {
   asNonEmptyStringArray
 } from "./chunk-I42VC5KR.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
@@ -2393,6 +2393,29 @@ var require_rambda = __commonJS({
   }
 });
 
+// packages/create/types.ts
+var DataType = /* @__PURE__ */ ((DataType2) => {
+  DataType2["AGENT"] = "agent";
+  DataType2["DOC"] = "page";
+  DataType2["DIALOG"] = "dialog";
+  DataType2["NOTIFICATION"] = "notification";
+  DataType2["MSG"] = "msg";
+  DataType2["TOKEN"] = "token";
+  DataType2["SPACE"] = "space";
+  DataType2["TRANSACTION"] = "transaction";
+  DataType2["SETTING"] = "setting";
+  DataType2["TASK"] = "task";
+  DataType2["AGENT_AUTOMATION"] = "agent-automation";
+  DataType2["TABLE"] = "table";
+  DataType2["TABLE_ROW"] = "table_row";
+  DataType2["FILE"] = "file";
+  DataType2["IMAGE"] = "image";
+  DataType2["APP"] = "app";
+  DataType2["EMAIL"] = "email";
+  DataType2["Category"] = "category";
+  return DataType2;
+})(DataType || {});
+
 // packages/core/toTrimmedString.ts
 function toTrimmedString(value) {
   return typeof value === "string" ? value.trim() : value == null ? "" : String(value).trim();
@@ -3167,6 +3190,7 @@ var sanitizeShareData = (data) => {
 };
 
 export {
+  DataType,
   ulid,
   toTrimmedString,
   toNonEmptyString,

package/{chunk-L3GCUVOH.js → chunk-KSRFVP36.js}

@@ -1,6 +1,6 @@
 import {
   dialogMessageRange
-} from "./chunk-WHLVPK32.js";
+} from "./chunk-KMSZPTM6.js";
 import {
   isTombstoneRecord
 } from "./chunk-GBRG75BQ.js";

package/{chunk-DLWCWUNW.js → chunk-LOD75GOS.js}

@@ -1,17 +1,20 @@
 import {
   applyChatCompletionDelta,
+  applyResponsesToolEvent,
+  createResponsesToolAccumulator,
+  finalizeResponsesToolCalls,
   flushChatCompletionStream,
   providerHttpFailure,
   readSseFrames,
   throwIfChatCompletionStreamFailed
-} from "./chunk-7S54ZGF6.js";
+} from "./chunk-RAZOLMJR.js";
 import {
   sanitizeForOutbound
 } from "./chunk-T27IEBNQ.js";
 import {
   parseToolArgumentsJson,
   resolveHistoricalToolContentCap
-} from "./chunk-AYMOSAHE.js";
+} from "./chunk-6PO2SYCS.js";
 import {
   createThinkParserState,
   createToolCallAccumulator,
@@ -22,24 +25,35 @@ import {
 import {
   requiresBareImageUrl,
   toBareImageUrlMessages
-} from "./chunk-3UGKATZQ.js";
+} from "./chunk-5SBK2MTI.js";
 import {
+  convertMessagesToResponsesInput,
+  extractReasoningFromResponseOutput,
+  extractTextFromResponseOutput,
+  extractToolCallsFromResponseOutput,
+  getUsageRequestOptions,
   shouldStripReasoningContentForOutbound,
-  toOpenAiCompatibleMessages
-} from "./chunk-D34RI6NI.js";
+  toOpenAiCompatibleMessages,
+  toResponsesTools
+} from "./chunk-NNWHHCVP.js";
 import {
   buildProviderAuthHeaders,
   buildProviderExecutionPlan
-} from "./chunk-UDA3ZYLW.js";
-import {
-  buildDialogFallbackTitleFromUserInput
-} from "./chunk-2MBTWINN.js";
+} from "./chunk-AFV4FOT2.js";
 import {
   NOLO_WORKSPACE_TOOL_NAMES,
   buildNoloWorkspaceCommandArgs,
+  noloPositiveIntegerString,
   noloStringArg,
-  parseNoloWorkspaceToolArguments
-} from "./chunk-D2BPX6DQ.js";
+  parseNoloWorkspaceToolArguments,
+  resolveNoloDialogInput
+} from "./chunk-ADLYMQB6.js";
+import {
+  buildDialogFallbackTitleFromUserInput
+} from "./chunk-2MBTWINN.js";
+import {
+  canonicalizeToolName
+} from "./chunk-ZZ2MH7LE.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
@@ -47,17 +61,18 @@ import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
 import {
-  asTrimmedLowercaseString
-} from "./chunk-QSJ3HFEF.js";
-import {
-  normalizeServerOrigin
-} from "./chunk-CF7PE763.js";
-import {
-  dialogMessageKey
-} from "./chunk-WHLVPK32.js";
+  dialogMessageKey,
+  dialogMessageRange
+} from "./chunk-KMSZPTM6.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";
+import {
+  asTrimmedNonEmptyStringArray
+} from "./chunk-I42VC5KR.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
@@ -68,11 +83,8 @@ import {
   isRecord
 } from "./chunk-KUG52IAP.js";
 import {
-  canonicalizeToolName
-} from "./chunk-3AUWC6EM.js";
-import {
-  asTrimmedNonEmptyStringArray
-} from "./chunk-I42VC5KR.js";
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
@@ -142,8 +154,173 @@ function parseSseDataLineObject(line) {
   return parsed && typeof parsed === "object" ? parsed : null;
 }
 
+// packages/integrations/openai/responsesRequestBody.ts
+function buildResponsesRequestBody(body, model) {
+  const tools = Array.isArray(body.tools) ? toResponsesTools(body.tools) : void 0;
+  const reasoningEffort = body.reasoning && typeof body.reasoning === "object" ? void 0 : typeof body.reasoning_effort === "string" && body.reasoning_effort.trim() ? body.reasoning_effort : void 0;
+  return {
+    ...body,
+    model,
+    input: Array.isArray(body.input) && body.input.length > 0 ? body.input : convertMessagesToResponsesInput(body.messages ?? []),
+    ...Array.isArray(body.tools) ? { tools: tools ?? void 0 } : {},
+    ...typeof body.max_tokens === "number" ? { max_output_tokens: body.max_tokens } : {},
+    ...reasoningEffort ? { reasoning: { effort: reasoningEffort } } : {},
+    messages: void 0,
+    max_tokens: void 0,
+    reasoning_effort: void 0,
+    tool_choice: void 0
+  };
+}
+
+// packages/agent-runtime/responsesSseStream.ts
+function toResponsesStreamFailure(raw, fallbackPrefix = "Responses") {
+  if (!raw || typeof raw !== "object") return void 0;
+  const err = raw;
+  const reason = typeof err.reason === "string" ? err.reason : void 0;
+  const message = typeof err.message === "string" && err.message ? err.message : reason ? `${fallbackPrefix} upstream ended incomplete: ${reason}.` : "";
+  if (!message) return void 0;
+  const code = typeof err.code === "string" ? err.code : reason;
+  return {
+    ...code ? { code } : {},
+    ...typeof err.type === "string" ? { type: err.type } : {},
+    message
+  };
+}
+function responsesStreamFailureStatus(failure) {
+  const marker = `${failure.code ?? ""} ${failure.type ?? ""}`.toLowerCase();
+  if (marker.includes("overload") || marker.includes("service_unavailable")) return 503;
+  if (marker.includes("rate_limit") || marker.includes("usage_limit")) return 429;
+  return 502;
+}
+var codexStreamFailureStatus = responsesStreamFailureStatus;
+function createResponsesStreamCollector(callbacks) {
+  let content = "";
+  let reasoning = "";
+  const toolCallsAcc = createResponsesToolAccumulator();
+  let usage;
+  let failure;
+  let completedResponse;
+  const processEvent = (ev) => {
+    const type = String(ev.type ?? "");
+    if (type === "error") {
+      failure = failure ?? toResponsesStreamFailure(ev.error, callbacks?.fallbackPrefix);
+      return;
+    }
+    if (type === "response.failed" || type === "response.incomplete") {
+      const response = ev.response;
+      failure = failure ?? toResponsesStreamFailure(response?.error, callbacks?.fallbackPrefix) ?? toResponsesStreamFailure(response?.incomplete_details, callbacks?.fallbackPrefix) ?? {
+        code: type === "response.incomplete" ? "response_incomplete" : "response_failed",
+        message: `${callbacks?.fallbackPrefix ?? "Responses"} upstream ended with ${type}.`
+      };
+      return;
+    }
+    if (type === "response.output_text.delta" && typeof ev.delta === "string") {
+      content += ev.delta;
+      callbacks?.onTextDelta?.(ev.delta);
+      return;
+    }
+    if ((type === "response.reasoning_text.delta" || type === "response.reasoning.delta") && typeof ev.delta === "string") {
+      reasoning += ev.delta;
+      callbacks?.onReasoningDelta?.(ev.delta);
+      return;
+    }
+    if (type === "response.output_item.added" || type === "response.output_item.done" || type === "response.function_call_arguments.delta" || type === "response.function_call_arguments.done") {
+      applyResponsesToolEvent(toolCallsAcc, ev);
+      return;
+    }
+    if (type === "response.completed") {
+      const response = ev.response;
+      if (response) {
+        completedResponse = response;
+        const u = response.usage;
+        if (u) {
+          const prompt = typeof u.input_tokens === "number" ? u.input_tokens : typeof u.prompt_tokens === "number" ? u.prompt_tokens : 0;
+          const completion = typeof u.output_tokens === "number" ? u.output_tokens : typeof u.completion_tokens === "number" ? u.completion_tokens : 0;
+          const total = typeof u.total_tokens === "number" ? u.total_tokens : prompt + completion;
+          usage = {
+            prompt_tokens: prompt,
+            completion_tokens: completion,
+            total_tokens: total
+          };
+        }
+      }
+    }
+  };
+  const finalize = () => {
+    let finalToolCalls = finalizeResponsesToolCalls(toolCallsAcc);
+    if (finalToolCalls.length === 0 && completedResponse) {
+      finalToolCalls = extractToolCallsFromResponseOutput(completedResponse);
+    }
+    if (!content && completedResponse) {
+      content = extractTextFromResponseOutput(completedResponse);
+    }
+    if (!reasoning && completedResponse) {
+      reasoning = extractReasoningFromResponseOutput(completedResponse);
+    }
+    return {
+      content,
+      ...reasoning ? { reasoning_content: reasoning } : {},
+      ...finalToolCalls.length > 0 ? { tool_calls: finalToolCalls } : {},
+      ...usage ? { usage } : {},
+      finish_reason: finalToolCalls.length > 0 ? "tool_calls" : "stop",
+      stream_complete: true,
+      ...failure ? { failure } : {}
+    };
+  };
+  return {
+    processEvent,
+    finalize
+  };
+}
+function aggregateResponsesStream(events, options) {
+  const collector = createResponsesStreamCollector({ fallbackPrefix: options?.fallbackPrefix ?? "Codex" });
+  for (const ev of events) {
+    collector.processEvent(ev);
+  }
+  const finalized = collector.finalize();
+  return {
+    text: finalized.content,
+    toolCalls: finalized.tool_calls ?? [],
+    usage: finalized.usage,
+    failure: finalized.failure
+  };
+}
+async function readResponsesSseCompletion(args) {
+  const collector = createResponsesStreamCollector({
+    onTextDelta: args.onTextDelta,
+    onReasoningDelta: args.onReasoningDelta,
+    fallbackPrefix: args.fallbackPrefix ?? "Responses"
+  });
+  for await (const frame of readSseFrames(args.response)) {
+    for (const line of frame.split("\n")) {
+      const parsed = parseSseDataLineObject(line);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        collector.processEvent(parsed);
+      }
+    }
+  }
+  const result = collector.finalize();
+  if (result.failure) {
+    const status = responsesStreamFailureStatus(result.failure);
+    const err = new Error(result.failure.message);
+    err.status = status;
+    err.code = result.failure.code;
+    err.type = result.failure.type;
+    throw err;
+  }
+  return result;
+}
+
 // packages/agent-runtime/openAiCompatibleProvider.ts
+function isOpenAiResponsesEndpoint(endpoint) {
+  return endpoint.includes("/responses");
+}
+function resolveOpenAiCompatibleWire(config) {
+  if (config.wire) return config.wire;
+  return isOpenAiResponsesEndpoint(config.endpoint) ? "responses" : "chat.completions";
+}
 function buildOpenAiCompatibleChatCompletionRequest(args) {
+  const isResponses = resolveOpenAiCompatibleWire(args.providerConfig) === "responses";
   const shouldStripReasoning = shouldStripReasoningContentForOutbound(
     args.providerConfig.provider,
     args.providerConfig.model
@@ -152,7 +329,7 @@ function buildOpenAiCompatibleChatCompletionRequest(args) {
   const messages = toOpenAiCompatibleMessages(sanitizedMessages, {
     stripReasoningContent: shouldStripReasoning
   });
-  const body = {
+  const rawBody = {
     model: args.providerConfig.model,
     messages: requiresBareImageUrl({
       endpoint: args.providerConfig.endpoint,
@@ -162,8 +339,9 @@ function buildOpenAiCompatibleChatCompletionRequest(args) {
     stream: args.stream ?? false,
     ...args.providerConfig.requestOptions,
     ...args.tools && args.tools.length > 0 ? { tools: args.tools } : {},
-    ...args.stream ? { stream_options: { include_usage: true } } : {}
+    ...!isResponses && args.stream ? getUsageRequestOptions(args.providerConfig.provider, { api: "chat-completions" }) : {}
   };
+  const body = isResponses ? buildResponsesRequestBody(rawBody, args.providerConfig.model) : rawBody;
   const endpoint = args.providerConfig.endpoint;
   const headers = {
     "Content-Type": "application/json",
@@ -183,6 +361,28 @@ function buildOpenAiCompatibleChatCompletionRequest(args) {
     }
   };
 }
+function parseOpenAiCompatibleResponsesResponse(args) {
+  const content = extractTextFromResponseOutput(args.data);
+  const reasoning = extractReasoningFromResponseOutput(args.data);
+  const tool_calls = extractToolCallsFromResponseOutput(args.data);
+  const u = args.data?.usage;
+  const usage = u && typeof u === "object" ? {
+    prompt_tokens: typeof u.input_tokens === "number" ? u.input_tokens : typeof u.prompt_tokens === "number" ? u.prompt_tokens : 0,
+    completion_tokens: typeof u.output_tokens === "number" ? u.output_tokens : typeof u.completion_tokens === "number" ? u.completion_tokens : 0,
+    total_tokens: typeof u.total_tokens === "number" ? u.total_tokens : (u.input_tokens ?? 0) + (u.output_tokens ?? 0)
+  } : void 0;
+  return {
+    content,
+    model: args.providerConfig.model,
+    provider: args.providerConfig.provider,
+    ...tool_calls.length > 0 ? { tool_calls } : {},
+    ...reasoning ? { reasoning_content: reasoning } : {},
+    finish_reason: tool_calls.length > 0 ? "tool_calls" : "stop",
+    stream_complete: true,
+    ...usage ? { usage } : {},
+    trace: args.trace
+  };
+}
 function parseOpenAiCompatibleChatCompletionResponse(args) {
   const choiceMessage = args.data?.choices?.[0]?.message ?? {};
   const rawContent = String(choiceMessage?.content ?? "");
@@ -236,6 +436,7 @@ async function readOpenAiCompatibleSseCompletion(args) {
   };
 }
 async function executeOpenAiCompatibleChatCompletion(args) {
+  const isResponses = resolveOpenAiCompatibleWire(args.providerConfig) === "responses";
   const send = async (apiKey2) => {
     const request = buildOpenAiCompatibleChatCompletionRequest({
       providerConfig: apiKey2 === args.providerConfig.apiKey ? args.providerConfig : { ...args.providerConfig, apiKey: apiKey2 },
@@ -272,6 +473,24 @@ async function executeOpenAiCompatibleChatCompletion(args) {
   const contentType = res.headers.get("content-type") ?? "";
   const isEventStream = contentType.includes("text/event-stream");
   if (isEventStream) {
+    if (isResponses) {
+      const streamed2 = await readResponsesSseCompletion({
+        response: res,
+        ...args.onTextDelta ? { onTextDelta: args.onTextDelta } : {},
+        ...args.onReasoningDelta ? { onReasoningDelta: args.onReasoningDelta } : {}
+      });
+      return {
+        content: streamed2.content,
+        model: args.providerConfig.model,
+        provider: args.providerConfig.provider,
+        ...streamed2.tool_calls ? { tool_calls: streamed2.tool_calls } : {},
+        ...streamed2.reasoning_content ? { reasoning_content: streamed2.reasoning_content } : {},
+        ...streamed2.usage ? { usage: streamed2.usage } : {},
+        ...streamed2.stream_complete ? { stream_complete: true } : {},
+        ...streamed2.finish_reason ? { finish_reason: streamed2.finish_reason } : {},
+        trace: args.messages
+      };
+    }
     const streamed = await readOpenAiCompatibleSseCompletion({
       response: res,
       ...args.onTextDelta ? { onTextDelta: args.onTextDelta } : {},
@@ -296,6 +515,13 @@ async function executeOpenAiCompatibleChatCompletion(args) {
   } catch {
     data = {};
   }
+  if (isResponses) {
+    return parseOpenAiCompatibleResponsesResponse({
+      providerConfig: args.providerConfig,
+      data,
+      trace: args.messages
+    });
+  }
   return parseOpenAiCompatibleChatCompletionResponse({
     providerConfig: args.providerConfig,
     data,
@@ -1887,13 +2113,13 @@ function buildExecShellTool(toolName) {
       parameters: {
         type: "object",
         properties: {
-          cmd: {
+          command: {
             type: "string",
             description: "Shell command to run (non-empty)."
           },
-          command: {
+          cmd: {
             type: "string",
-            description: "Compatibility alias for cmd."
+            description: "Compatibility alias for command."
           }
         }
       }
@@ -4029,6 +4255,23 @@ function createLocalWorkspaceToolExecutors(args) {
   };
 }
 
+// packages/cli/client/localDialogRecords.ts
+var localDialogMessageRecordToRuntimeMessage = dialogMessageRecordToAgentRuntimeMessage;
+function buildLocalDialogWritePlan(args) {
+  return buildAgentRuntimeDialogWritePlan({
+    input: args.input,
+    userId: args.userId,
+    now: args.now,
+    createId: args.createId,
+    existingDialog: args.existingDialog,
+    runtimeHost: "cli",
+    runtimeMetadata: {
+      ...args.cwd ? { worktreePath: args.cwd } : {}
+    },
+    ...args.titleOverride ? { titleOverride: args.titleOverride } : {}
+  });
+}
+
 // packages/agent-runtime/noloWorkspaceTools.node.ts
 async function readNoloProcessStream(readable) {
   if (!readable) return "";
@@ -4065,10 +4308,67 @@ async function runNoloWorkspaceCliTool(call, args) {
     }
   };
 }
+async function readDialogInProcess(call, store, env) {
+  const args = parseNoloWorkspaceToolArguments(call.arguments);
+  const dialogInput = noloStringArg(args.dialog ?? args.dialogId ?? args.id);
+  if (!dialogInput) throw new Error("readDialog requires dialog.");
+  const mode = noloStringArg(args.mode);
+  if (mode && mode !== "full" && mode !== "status") {
+    throw new Error(`readDialog mode must be "full" or "status", got "${mode}".`);
+  }
+  const userId = noloStringArg(args.user ?? args.userId ?? args.owner) || env?.NOLO_LOCAL_USER_ID || env?.NOLO_USER_ID || "";
+  const { dbKey: dialogKey, dialogId } = resolveNoloDialogInput(dialogInput, userId);
+  const meta = await store.read(dialogKey, { remote: false });
+  if (mode === "status") {
+    const result2 = {
+      dialogId,
+      dialogKey,
+      meta,
+      status: meta?.status ?? null,
+      runtimeCheckpoint: meta?.runtimeCheckpoint ?? null,
+      source: "in-process"
+    };
+    return {
+      content: JSON.stringify(result2, null, 2),
+      metadata: { noloWorkspaceTool: true, readDialog: true, inProcess: true, mode: "status" }
+    };
+  }
+  const limitNum = noloPositiveIntegerString(args.limit);
+  const limit = limitNum ? Number(limitNum) : void 0;
+  const rawMessages = [];
+  if (store.iterator) {
+    const { start, end } = dialogMessageRange(dialogId);
+    for await (const [, value] of store.iterator({ gte: start, lte: end })) {
+      const message = localDialogMessageRecordToRuntimeMessage(value);
+      if (message) {
+        rawMessages.push(message);
+      } else if (value) {
+        rawMessages.push(value);
+      }
+    }
+  }
+  const messages = limit !== void 0 && rawMessages.length > limit ? rawMessages.slice(rawMessages.length - limit) : rawMessages;
+  const result = {
+    dialogId,
+    dialogKey,
+    meta,
+    messages,
+    messagesCount: messages.length,
+    source: "in-process"
+  };
+  return {
+    content: JSON.stringify(result, null, 2),
+    metadata: { noloWorkspaceTool: true, readDialog: true, inProcess: true }
+  };
+}
 function buildNoloWorkspaceCliToolExecutors(args) {
   const executors = {};
   for (const toolName of NOLO_WORKSPACE_TOOL_NAMES) {
     if (toolName === "loadSkill") continue;
+    if (toolName === "readDialog" && args.store) {
+      executors[toolName] = (call) => readDialogInProcess(call, args.store, args.env);
+      continue;
+    }
     executors[toolName] = (call) => runNoloWorkspaceCliTool(call, args);
   }
   return executors;
@@ -4086,10 +4386,10 @@ function buildLoadSkillExecutor(args) {
         metadata: { loadSkill: true, resolved: false }
       };
     }
-    const { resolveSkillByName } = await import("./skillDiscovery-5U6RYAHN.js");
+    const { resolveSkillByName } = await import("./skillDiscovery-KLLKXPUO.js");
     const resolved = resolveSkillByName(args.cwd, name);
     if (!resolved) {
-      const { resolveCodingBuiltinSlug, buildCodingSkillContentBySlug } = await import("./codingSkills-V35TRR4Y.js");
+      const { resolveCodingBuiltinSlug, buildCodingSkillContentBySlug } = await import("./codingSkills-DY5MINPG.js");
       const builtinSlug = resolveCodingBuiltinSlug(name);
       if (builtinSlug) {
         const body = buildCodingSkillContentBySlug(builtinSlug);
@@ -4124,7 +4424,7 @@ ${body}`,
   };
 }
 async function formatUnknownSkillMessage(cwd, requestedName) {
-  const { discoverSkills } = await import("./skillDiscovery-5U6RYAHN.js");
+  const { discoverSkills } = await import("./skillDiscovery-KLLKXPUO.js");
   let available = [];
   try {
     available = discoverSkills(cwd).map((s) => s.name);
@@ -4144,6 +4444,8 @@ export {
   isAgentCoolingDown,
   parseSseDataLineJson,
   parseSseDataLineObject,
+  codexStreamFailureStatus,
+  aggregateResponsesStream,
   buildOpenAiCompatibleChatCompletionRequest,
   parseOpenAiCompatibleChatCompletionResponse,
   readOpenAiCompatibleSseCompletion,
@@ -4165,6 +4467,8 @@ export {
   buildLocalWorkspacePolicyToolNames,
   buildLocalWorkspaceOpenAiTools,
   createLocalWorkspaceToolExecutors,
+  localDialogMessageRecordToRuntimeMessage,
+  buildLocalDialogWritePlan,
   buildNoloWorkspaceCliToolExecutors,
   buildLoadSkillExecutor
 };