@ebowwa/coder 0.7.66 → 0.7.68

package/dist/interfaces/ui/terminal/cli/index.js

@@ -7378,6 +7378,69 @@ function convertToolsToOpenAIFormat(tools) {
     }
   }));
 }
+function convertMessagesToOpenAIFormat(messages) {
+  const result = [];
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      const toolCalls = [];
+      const textParts = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          textParts.push(block.text);
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            type: "function",
+            function: {
+              name: block.name,
+              arguments: JSON.stringify(block.input)
+            }
+          });
+        } else if (block.type === "thinking" || block.type === "redacted_thinking") {}
+      }
+      const openAIMsg = {
+        role: "assistant",
+        content: textParts.join(`
+`) || null
+      };
+      if (toolCalls.length > 0) {
+        openAIMsg.tool_calls = toolCalls;
+      }
+      result.push(openAIMsg);
+    } else if (msg.role === "user") {
+      const textParts = [];
+      const toolResults = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          textParts.push(block.text);
+        } else if (block.type === "tool_result") {
+          const contentStr = typeof block.content === "string" ? block.content : block.content.map((c) => c.type === "text" ? c.text : JSON.stringify(c)).join(`
+`);
+          toolResults.push({
+            tool_use_id: block.tool_use_id,
+            content: contentStr,
+            is_error: block.is_error
+          });
+        }
+      }
+      if (textParts.length > 0) {
+        result.push({
+          role: "user",
+          content: textParts.join(`
+`)
+        });
+      }
+      for (const tr of toolResults) {
+        result.push({
+          role: "tool",
+          tool_call_id: tr.tool_use_id,
+          content: tr.content
+        });
+      }
+    }
+  }
+  return result;
+}
 function calculateCost2(model, usage) {
   return calculateCost(model, usage);
 }
@@ -7771,20 +7834,6 @@ async function createMessageStream(messages, options) {
     signal
   } = options;
   const startTime = Date.now();
-  const cachedMessages = buildCachedMessages(messages, cacheConfig);
-  const cachedSystemPrompt = buildSystemPrompt(systemPrompt, cacheConfig);
-  const request = {
-    model,
-    max_tokens: maxTokens,
-    messages: cachedMessages.map((m) => ({
-      role: m.role,
-      content: m.content
-    })),
-    stream: true
-  };
-  if (cachedSystemPrompt) {
-    request.system = cachedSystemPrompt;
-  }
   const providerInfo = resolveProvider(model);
   let apiEndpoint;
   let headers;
@@ -7814,6 +7863,37 @@ async function createMessageStream(messages, options) {
       "anthropic-version": "2023-06-01"
     };
   }
+  const cachedMessages = buildCachedMessages(messages, cacheConfig);
+  const cachedSystemPrompt = buildSystemPrompt(systemPrompt, cacheConfig);
+  let requestMessages;
+  if (apiFormat === "openai") {
+    const openAIMessages = convertMessagesToOpenAIFormat(cachedMessages);
+    if (cachedSystemPrompt) {
+      const systemText = typeof cachedSystemPrompt === "string" ? cachedSystemPrompt : cachedSystemPrompt.map((b) => b.text).join(`
+
+`);
+      requestMessages = [
+        { role: "system", content: systemText },
+        ...openAIMessages
+      ];
+    } else {
+      requestMessages = openAIMessages;
+    }
+  } else {
+    requestMessages = cachedMessages.map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+  }
+  const request = {
+    model,
+    max_tokens: maxTokens,
+    messages: requestMessages,
+    stream: true
+  };
+  if (cachedSystemPrompt && apiFormat === "anthropic") {
+    request.system = cachedSystemPrompt;
+  }
   if (tools && tools.length > 0) {
     if (apiFormat === "openai") {
       request.tools = convertToolsToOpenAIFormat(tools);
@@ -11249,6 +11329,84 @@ var init_spinner_frames = __esm(() => {
   ];
 });
 
+// packages/src/interfaces/ui/terminal/cli/interactive/scroll-handler.ts
+function handleScrollEvent(event, currentOffset, totalMessages, config = {}) {
+  const { pageScrollAmount, lineScrollAmount } = { ...DEFAULT_SCROLL_CONFIG, ...config };
+  const maxScroll = Math.max(0, Math.max(totalMessages - 1, 10));
+  if (process.env.CODER_DEBUG_SCROLL === "1") {
+    console.error("[ScrollHandler] Event:", {
+      code: event.code,
+      shift: event.shift,
+      ctrl: event.ctrl,
+      alt: event.alt,
+      is_special: event.is_special
+    });
+  }
+  if (KeyEvents.isPageUp(event)) {
+    if (process.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[ScrollHandler] PageUp detected, scrolling up");
+    }
+    return { handled: true, newOffset: Math.min(currentOffset + pageScrollAmount, maxScroll) };
+  }
+  if (KeyEvents.isPageDown(event)) {
+    if (process.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[ScrollHandler] PageDown detected, scrolling down");
+    }
+    return { handled: true, newOffset: Math.max(0, currentOffset - pageScrollAmount) };
+  }
+  if (KeyEvents.isHome(event)) {
+    if (process.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[ScrollHandler] Home detected, resetting to bottom");
+    }
+    return { handled: true, newOffset: 0 };
+  }
+  if (KeyEvents.isUp(event) && event.alt) {
+    if (process.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[ScrollHandler] Alt+Up detected, scrolling up");
+    }
+    return { handled: true, newOffset: Math.min(currentOffset + lineScrollAmount, maxScroll) };
+  }
+  if (KeyEvents.isDown(event) && event.alt) {
+    if (process.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[ScrollHandler] Alt+Down detected, scrolling down");
+    }
+    return { handled: true, newOffset: Math.max(0, currentOffset - lineScrollAmount) };
+  }
+  if (KeyEvents.isUp(event) && event.ctrl) {
+    if (process.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[ScrollHandler] Ctrl+Up detected, scrolling up");
+    }
+    return { handled: true, newOffset: Math.min(currentOffset + lineScrollAmount, maxScroll) };
+  }
+  if (KeyEvents.isDown(event) && event.ctrl) {
+    if (process.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[ScrollHandler] Ctrl+Down detected, scrolling down");
+    }
+    return { handled: true, newOffset: Math.max(0, currentOffset - lineScrollAmount) };
+  }
+  if (KeyEvents.isUp(event) && event.shift) {
+    if (process.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[ScrollHandler] Shift+Up detected, scrolling up");
+    }
+    return { handled: true, newOffset: Math.min(currentOffset + lineScrollAmount, maxScroll) };
+  }
+  if (KeyEvents.isDown(event) && event.shift) {
+    if (process.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[ScrollHandler] Shift+Down detected, scrolling down");
+    }
+    return { handled: true, newOffset: Math.max(0, currentOffset - lineScrollAmount) };
+  }
+  return { handled: false, newOffset: currentOffset };
+}
+var DEFAULT_SCROLL_CONFIG;
+var init_scroll_handler = __esm(() => {
+  init_input_handler();
+  DEFAULT_SCROLL_CONFIG = {
+    pageScrollAmount: 3,
+    lineScrollAmount: 1
+  };
+});
+
 // packages/src/interfaces/ui/terminal/cli/interactive/interactive-runner.ts
 import process3 from "process";
 function createInitialState() {
@@ -11399,6 +11557,23 @@ class InteractiveRunner {
       this.state = { ...this.state, inputValue: "", cursorPos: 0 };
       return true;
     }
+    if (process3.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[InteractiveRunner] Key event:", {
+        code: event.code,
+        shift: event.shift,
+        ctrl: event.ctrl,
+        alt: event.alt,
+        is_special: event.is_special
+      });
+    }
+    const scrollResult = handleScrollEvent(event, this.state.scrollOffset, this.messageStore.messages.length);
+    if (process3.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[InteractiveRunner] Scroll result:", scrollResult);
+    }
+    if (scrollResult.handled) {
+      this.state = { ...this.state, scrollOffset: scrollResult.newOffset };
+      return true;
+    }
     if (KeyEvents.isUp(event)) {
       return this._handleHistoryUp();
     }
@@ -11696,18 +11871,19 @@ class InteractiveRunner {
     })) : [];
     return {
       messages: renderMessages,
-      inputValue,
-      cursorPos,
-      statusText,
-      isLoading,
-      streamingText,
+      input_value: inputValue,
+      cursor_pos: cursorPos,
+      status_text: statusText,
+      is_loading: isLoading,
+      streaming_text: streamingText,
       model: this.props.model,
-      showHelp: helpMode,
-      helpText,
-      searchMode: sessionSelectMode,
-      searchQuery: "",
-      searchResults,
-      searchSelected: 0
+      show_help: helpMode,
+      help_text: helpText,
+      search_mode: sessionSelectMode,
+      search_query: "",
+      search_results: searchResults,
+      search_selected: 0,
+      scroll_offset: this.state.scrollOffset
     };
   }
   _getHelpText(section) {
@@ -11809,6 +11985,7 @@ var init_interactive_runner = __esm(() => {
   init_native();
   init_spinner_frames();
   init_input_handler();
+  init_scroll_handler();
   init_types();
 });
 
@@ -34325,3 +34502,6 @@ if (checkPtyWrapper2()) {
     process5.exit(1);
   });
 }
+
+//# debugId=7897AF5E6C87CE9064756E2164756E21
+//# sourceMappingURL=bootstrap.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/coder",
-  "version": "0.7.66",
+  "version": "0.7.68",
   "description": "AI-powered terminal coding assistant",
   "author": "ebowwa",
   "license": "MIT",
@@ -24,7 +24,7 @@
   },
   "scripts": {
     "build": "bun run build:native && bun run build:ts && bun run link",
-    "build:ts": "bun build ./packages/src/index.ts ./packages/src/interfaces/ui/terminal/cli/bootstrap.ts --outdir ./dist --target bun --external @ebowwa/coder-native && cp -r native dist/ && mkdir -p dist/interfaces/ui/terminal && cp -r native dist/interfaces/ui/terminal/ && mv dist/interfaces/ui/terminal/cli/bootstrap.js dist/interfaces/ui/terminal/cli/index.js",
+    "build:ts": "bun build ./packages/src/index.ts ./packages/src/interfaces/ui/terminal/cli/bootstrap.ts --outdir ./dist --target bun --external @ebowwa/coder-native --sourcemap && cp -r native dist/ && mkdir -p dist/interfaces/ui/terminal && cp -r native dist/interfaces/ui/terminal/ && mv dist/interfaces/ui/terminal/cli/bootstrap.js dist/interfaces/ui/terminal/cli/index.js",
     "build:native": "cd packages/rust && cargo build --release --target-dir ./target && cd ../.. && bun run build:napi-artifacts",
     "build:napi-artifacts": "napi build --platform --release --target-dir packages/rust/target --manifest-path packages/rust/Cargo.toml --output-dir native --js-package-name @ebowwa/coder-native --const-enum --strip --dts index.d.ts",
     "link": "bun link || npm link",

package/packages/src/core/api-client-impl.ts

@@ -63,6 +63,115 @@ function convertToolsToOpenAIFormat(tools: APITool[]): unknown[] {
   }));
 }
 
+/**
+ * OpenAI-format message types
+ */
+interface OpenAIToolCall {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+interface OpenAIMessage {
+  role: "user" | "assistant" | "tool" | "system";
+  content: string | null;
+  tool_calls?: OpenAIToolCall[];
+  tool_call_id?: string;
+  name?: string;
+}
+
+/**
+ * Convert Anthropic-style messages to OpenAI-style messages
+ *
+ * Key conversions:
+ * 1. Assistant messages with tool_use → add tool_calls array
+ * 2. User messages with tool_result → separate role: "tool" messages
+ *
+ * This is required because OpenAI-format APIs (Zhipu, etc.) don't understand
+ * Anthropic's tool_result content block type.
+ */
+function convertMessagesToOpenAIFormat(messages: Message[]): OpenAIMessage[] {
+  const result: OpenAIMessage[] = [];
+
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      // Assistant message - check for tool_use blocks
+      const toolCalls: OpenAIToolCall[] = [];
+      const textParts: string[] = [];
+
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          textParts.push(block.text);
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            type: "function",
+            function: {
+              name: block.name,
+              arguments: JSON.stringify(block.input),
+            },
+          });
+        } else if (block.type === "thinking" || block.type === "redacted_thinking") {
+          // Skip thinking blocks in OpenAI format (not supported)
+        }
+      }
+
+      const openAIMsg: OpenAIMessage = {
+        role: "assistant",
+        content: textParts.join("\n") || null,
+      };
+
+      if (toolCalls.length > 0) {
+        openAIMsg.tool_calls = toolCalls;
+      }
+
+      result.push(openAIMsg);
+    } else if (msg.role === "user") {
+      // User message - check for tool_result blocks
+      const textParts: string[] = [];
+      const toolResults: { tool_use_id: string; content: string; is_error?: boolean }[] = [];
+
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          textParts.push(block.text);
+        } else if (block.type === "tool_result") {
+          // Extract content as string
+          const contentStr = typeof block.content === "string"
+            ? block.content
+            : block.content.map(c => c.type === "text" ? c.text : JSON.stringify(c)).join("\n");
+          toolResults.push({
+            tool_use_id: block.tool_use_id,
+            content: contentStr,
+            is_error: block.is_error,
+          });
+        }
+      }
+
+      // Add text content as user message if present
+      if (textParts.length > 0) {
+        result.push({
+          role: "user",
+          content: textParts.join("\n"),
+        });
+      }
+
+      // Add each tool result as a separate "tool" role message
+      for (const tr of toolResults) {
+        result.push({
+          role: "tool",
+          tool_call_id: tr.tool_use_id,
+          content: tr.content,
+        });
+      }
+    }
+  }
+
+  return result;
+}
+
 export interface StreamOptions {
   apiKey: string;
   model?: string;
@@ -647,30 +756,7 @@ export async function createMessageStream(
 
   const startTime = Date.now();
 
-  // Build cached messages
-  const cachedMessages = buildCachedMessages(messages, cacheConfig);
-
-  // Build system prompt with cache control
-  const cachedSystemPrompt = buildSystemPrompt(systemPrompt, cacheConfig);
-
-  // Build request
-  const request: APIRequest = {
-    model,
-    max_tokens: maxTokens,
-    messages: cachedMessages.map((m) => ({
-      role: m.role,
-      content: m.content,
-    })),
-    stream: true,
-  };
-
-  if (cachedSystemPrompt) {
-    request.system = cachedSystemPrompt;
-  }
-
-  // Tools will be set after determining API format (for format conversion)
-
-  // Resolve provider based on model name
+  // Resolve provider FIRST to determine API format
   const providerInfo = resolveProvider(model);
 
   // Determine API endpoint and headers based on provider
@@ -710,6 +796,52 @@ export async function createMessageStream(
     };
   }
 
+  // Build cached messages
+  const cachedMessages = buildCachedMessages(messages, cacheConfig);
+
+  // Build system prompt with cache control
+  const cachedSystemPrompt = buildSystemPrompt(systemPrompt, cacheConfig);
+
+  // Build request with format-appropriate message conversion
+  let requestMessages: unknown;
+  if (apiFormat === "openai") {
+    // Convert to OpenAI format (handles tool_use and tool_result properly)
+    const openAIMessages = convertMessagesToOpenAIFormat(cachedMessages);
+
+    // Add system prompt as first message for OpenAI format
+    if (cachedSystemPrompt) {
+      const systemText = typeof cachedSystemPrompt === "string"
+        ? cachedSystemPrompt
+        : cachedSystemPrompt.map(b => b.text).join("\n\n");
+      requestMessages = [
+        { role: "system", content: systemText },
+        ...openAIMessages,
+      ];
+    } else {
+      requestMessages = openAIMessages;
+    }
+  } else {
+    // Keep Anthropic format
+    requestMessages = cachedMessages.map((m) => ({
+      role: m.role,
+      content: m.content,
+    }));
+  }
+
+  // Build request
+  const request: APIRequest = {
+    model,
+    max_tokens: maxTokens,
+    messages: requestMessages as Message[],
+    stream: true,
+  };
+
+  if (cachedSystemPrompt && apiFormat === "anthropic") {
+    // Anthropic format uses separate system field
+    // OpenAI format already has system as first message
+    request.system = cachedSystemPrompt;
+  }
+
   // Set tools with format conversion if needed
   if (tools && tools.length > 0) {
     if (apiFormat === "openai") {

package/packages/src/interfaces/ui/terminal/cli/interactive/interactive-runner.ts

@@ -23,6 +23,7 @@ import type { InputEvent, NativeRendererType } from "../../../../../native/index
 import { spinnerFrames } from "../../shared/spinner-frames.js";
 import { MessageStoreImpl } from "./message-store.js";
 import { InputManagerImpl, KeyEvents, inputEventToNativeKeyEvent } from "./input-handler.js";
+import { handleScrollEvent } from "./scroll-handler.js";
 import type {
   InteractiveRunnerProps,
   InteractiveState,
@@ -269,7 +270,34 @@ export class InteractiveRunner {
       return true;
     }
 
-    // History navigation
+    // Chat history scroll - handle all scroll keys via scroll handler
+    // Debug: log event details
+    if (process.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[InteractiveRunner] Key event:", {
+        code: event.code,
+        shift: event.shift,
+        ctrl: event.ctrl,
+        alt: event.alt,
+        is_special: event.is_special,
+      });
+    }
+
+    const scrollResult = handleScrollEvent(
+      event,
+      this.state.scrollOffset,
+      this.messageStore.messages.length
+    );
+
+    if (process.env.CODER_DEBUG_SCROLL === "1") {
+      console.error("[InteractiveRunner] Scroll result:", scrollResult);
+    }
+
+    if (scrollResult.handled) {
+      this.state = { ...this.state, scrollOffset: scrollResult.newOffset };
+      return true;
+    }
+
+    // History navigation (plain Up/Down without shift)
     if (KeyEvents.isUp(event)) {
       return this._handleHistoryUp();
     }
@@ -682,21 +710,22 @@ export class InteractiveRunner {
       content: `${s.messageCount} messages`,
     })) : [];
 
-    // NativeRenderer expects camelCase field names (NAPI-RS converts snake_case to camelCase)
+    // NativeRenderer expects snake_case field names (NAPI-RS keeps Rust naming)
     return {
       messages: renderMessages,
-      inputValue: inputValue,
-      cursorPos: cursorPos,
-      statusText: statusText,
-      isLoading: isLoading,
-      streamingText: streamingText,
+      input_value: inputValue,
+      cursor_pos: cursorPos,
+      status_text: statusText,
+      is_loading: isLoading,
+      streaming_text: streamingText,
       model: this.props.model,
-      showHelp: helpMode,
-      helpText: helpText,
-      searchMode: sessionSelectMode,
-      searchQuery: "",
-      searchResults: searchResults,
-      searchSelected: 0,
+      show_help: helpMode,
+      help_text: helpText,
+      search_mode: sessionSelectMode,
+      search_query: "",
+      search_results: searchResults,
+      search_selected: 0,
+      scroll_offset: this.state.scrollOffset,
     };
   }