@agentprojectcontext/apx 1.17.0 → 1.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentprojectcontext/apx",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "APX — unified CLI + daemon for the Agent Project Context (APC) standard.",
   "publishConfig": {
     "access": "public"
@@ -35,10 +35,6 @@
   },
   "packageManager": "pnpm@10.25.0",
   "dependencies": {
-    "@langchain/anthropic": "^0.3.34",
-    "@langchain/community": "^0.3.59",
-    "@langchain/core": "^0.3.80",
-    "@langchain/ollama": "^0.2.4",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opentui/core": "^0.2.8",
     "@opentui/keymap": "^0.2.8",
@@ -56,7 +52,6 @@
     "express": "^4.21.0",
     "fuzzysort": "^3.1.0",
     "jsonc-parser": "^3.3.1",
-    "langchain": "^0.3.37",
     "node-fetch": "^3.3.2",
     "open": "^11.0.0",
     "opentui-spinner": "^0.0.6",

package/src/daemon/super-agent.js

@@ -226,19 +226,6 @@ export async function runSuperAgent({
   const sa = globalConfig.super_agent;
   const activeModel = overrideModel || sa.model;
 
-  // Engine toggle: if config.super_agent.engine === "langchain", delegate to
-  // the LangChain AgentExecutor adapter. Default stays "native" (this loop).
-  // The toggle exists so we can A/B the two paths on the user's actual chat
-  // without committing to a full migration. See super-agent-langchain.js.
-  if (sa.engine === "langchain") {
-    const { runSuperAgentLangChain } = await import("./super-agent-langchain.js");
-    return runSuperAgentLangChain({
-      globalConfig, projects, plugins, registries,
-      prompt, previousMessages, contextNote,
-      onEvent, onToken, signal,
-    });
-  }
-
   // Tiny project hint — JUST names + ids, no detail. The model is expected to
   // call list_agents / list_mcps / read_agent_memory / etc. for everything
   // else. Keeping this short forces actual tool use instead of letting the

package/src/tui/context/sdk-apx.tsx

@@ -4,6 +4,7 @@ import { onCleanup } from "solid-js"
 import fs from "node:fs"
 import os from "node:os"
 import path from "node:path"
+import { spawn } from "node:child_process"
 
 const TOKEN_PATH = path.join(os.homedir(), ".apx", "daemon.token")
 
@@ -20,6 +21,9 @@ export type ApxEvent =
   | { type: "chunk"; sessionID: string; chunk: string }
   | { type: "final"; sessionID: string; text: string; usage?: { input_tokens: number; output_tokens: number } }
   | { type: "error"; sessionID: string; error: string }
+  | { type: "shell.start"; sessionID: string; shellID: string; command: string; cwd: string }
+  | { type: "shell.output"; sessionID: string; shellID: string; stream: "stdout" | "stderr"; chunk: string }
+  | { type: "shell.done"; sessionID: string; shellID: string; exitCode: number | null; signal: NodeJS.Signals | null }
 
 export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
   name: "SDK",
@@ -102,6 +106,27 @@ export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
       return (data as any).id as string
     }
 
+    function runShell(sessionID: string, command: string, cwd: string = process.cwd()): Promise<{ shellID: string; exitCode: number | null }> {
+      const shellID = `sh-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`
+      emitter.emit("event", { type: "shell.start", sessionID, shellID, command, cwd })
+      return new Promise((resolve) => {
+        const child = spawn(command, { shell: true, cwd, env: process.env })
+        child.stdout?.on("data", (buf) => {
+          emitter.emit("event", { type: "shell.output", sessionID, shellID, stream: "stdout", chunk: buf.toString() })
+        })
+        child.stderr?.on("data", (buf) => {
+          emitter.emit("event", { type: "shell.output", sessionID, shellID, stream: "stderr", chunk: buf.toString() })
+        })
+        child.on("error", (err) => {
+          emitter.emit("event", { type: "shell.output", sessionID, shellID, stream: "stderr", chunk: `[spawn error] ${err.message}\n` })
+        })
+        child.on("close", (code, signal) => {
+          emitter.emit("event", { type: "shell.done", sessionID, shellID, exitCode: code, signal })
+          resolve({ shellID, exitCode: code })
+        })
+      })
+    }
+
     async function listSessions(): Promise<Array<{ id: string; title: string; updatedAt?: number }>> {
       try {
         const token = readToken()
@@ -146,7 +171,12 @@ export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
         fork: async (_opts: any) => ({ data: undefined, error: new Error("not supported") }),
         abort: async (_opts: any) => {},
         prompt: async (_opts: any) => {},
-        shell: async (_opts: any) => {},
+        shell: async (opts: { sessionID?: string; command?: string; cwd?: string }) => {
+          if (!opts?.command) return { data: undefined }
+          const sid = opts.sessionID || (await createSession())
+          const r = await runShell(sid, opts.command, opts.cwd)
+          return { data: r }
+        },
         command: async (_opts: any) => {},
         refresh: async () => {},
         update: async (_opts: any) => ({ data: undefined }),
@@ -180,6 +210,7 @@ export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
       streamChat,
       createSession,
       listSessions,
+      runShell,
     }
   },
 })

package/src/tui/context/sync-apx.tsx

@@ -13,10 +13,15 @@ export type ApxSession = {
 export type ApxMessage = {
   id: string
   sessionID: string
-  role: "user" | "assistant"
+  role: "user" | "assistant" | "shell"
   text: string
   streaming?: boolean
   error?: boolean
+  // Shell-specific
+  shellID?: string
+  command?: string
+  cwd?: string
+  exitCode?: number | null
 }
 
 export const { use: useApxSync, provider: ApxSyncProvider } = createSimpleContext({
@@ -78,6 +83,55 @@ export const { use: useApxSync, provider: ApxSyncProvider } = createSimpleContex
         setStore("previousMessages", (prev) => [...prev, { role: "assistant", content: e.text }])
       }
 
+      if (ev.type === "shell.start") {
+        const e = ev
+        setStore(
+          "messages",
+          produce((draft) => {
+            ;(draft[e.sessionID] ??= []).push({
+              id: e.shellID,
+              sessionID: e.sessionID,
+              role: "shell",
+              text: "",
+              streaming: true,
+              shellID: e.shellID,
+              command: e.command,
+              cwd: e.cwd,
+            })
+          }),
+        )
+      }
+
+      if (ev.type === "shell.output") {
+        const e = ev
+        setStore(
+          "messages",
+          produce((draft) => {
+            const msgs = draft[e.sessionID]
+            if (!msgs) return
+            const target = msgs.find((m) => m.role === "shell" && m.shellID === e.shellID)
+            if (target) target.text += e.chunk
+          }),
+        )
+      }
+
+      if (ev.type === "shell.done") {
+        const e = ev
+        setStore(
+          "messages",
+          produce((draft) => {
+            const msgs = draft[e.sessionID]
+            if (!msgs) return
+            const target = msgs.find((m) => m.role === "shell" && m.shellID === e.shellID)
+            if (target) {
+              target.streaming = false
+              target.exitCode = e.exitCode
+              if (e.signal) target.text += `\n[killed by signal ${e.signal}]`
+            }
+          }),
+        )
+      }
+
       if (ev.type === "error") {
         const e = ev
         setStore(
@@ -121,6 +175,11 @@ export const { use: useApxSync, provider: ApxSyncProvider } = createSimpleContex
       return id
     }
 
+    async function runShell(command: string, cwd?: string) {
+      const sessionID = await ensureSession()
+      await sdk.runShell(sessionID, command, cwd ?? process.cwd())
+    }
+
     async function sendMessage(text: string) {
       const sessionID = await ensureSession()
       const userMsg: ApxMessage = {
@@ -172,6 +231,7 @@ export const { use: useApxSync, provider: ApxSyncProvider } = createSimpleContex
         async refresh() {},
       },
       sendMessage,
+      runShell,
       ensureSession,
     }
   },

package/src/tui/routes/session/index.tsx

@@ -47,6 +47,35 @@ function AssistantBubble(props: { msg: ApxMessage }) {
   )
 }
 
+function ShellBubble(props: { msg: ApxMessage }) {
+  const { theme } = useTheme()
+  const header = () => {
+    const code = props.msg.exitCode
+    const status = props.msg.streaming
+      ? "running"
+      : code === 0
+        ? "exit 0"
+        : code == null
+          ? "ended"
+          : `exit ${code}`
+    return `$ ${props.msg.command ?? ""}  · ${status}`
+  }
+  const body = () => props.msg.text || (props.msg.streaming ? "…" : "(no output)")
+  return (
+    <box flexDirection="column" marginBottom={1} paddingLeft={2} paddingRight={2}>
+      <text color={theme.warning ?? theme.primary} bold>
+        {header()}
+      </text>
+      <text
+        color={props.msg.exitCode && props.msg.exitCode !== 0 ? theme.error : theme.text}
+        wrap
+      >
+        {body()}
+      </text>
+    </box>
+  )
+}
+
 export function Session() {
   const dims = useTerminalDimensions()
   const { theme } = useTheme()
@@ -109,7 +138,11 @@ export function Session() {
     inputEl.clear()
     setSending(true)
     try {
-      await sync.sendMessage(text)
+      if (text.startsWith("!") && text.length > 1) {
+        await sync.runShell(text.slice(1).trim())
+      } else {
+        await sync.sendMessage(text)
+      }
     } catch (e) {
       toast.error(e instanceof Error ? e : new Error(String(e)))
     } finally {
@@ -132,17 +165,17 @@ export function Session() {
             fallback={
               <box paddingLeft={2} paddingTop={2}>
                 <text color={theme.textMuted} italic>
-                  Type a message and press Enter to start chatting.
+                  Type a message to chat, or prefix with ! to run a shell command (e.g. !ls).
                 </text>
               </box>
             }
           >
             <For each={messages()}>
-              {(msg) => (
-                <Show when={msg.role === "user"} fallback={<AssistantBubble msg={msg} />}>
-                  <UserBubble msg={msg} />
-                </Show>
-              )}
+              {(msg) => {
+                if (msg.role === "user") return <UserBubble msg={msg} />
+                if (msg.role === "shell") return <ShellBubble msg={msg} />
+                return <AssistantBubble msg={msg} />
+              }}
             </For>
           </Show>
           <box height={1} />
@@ -163,7 +196,7 @@ export function Session() {
               inputEl = r
               promptRef.set(makeRef(r))
             }}
-            placeholder={sending() ? "Waiting for response…" : "Ask anything... (Enter to send)"}
+            placeholder={sending() ? "Waiting for response…" : "Ask anything... (prefix ! to run shell, e.g. !ls)"}
             placeholderColor={theme.textMuted}
             textColor={theme.text}
             focusedTextColor={theme.text}

package/src/daemon/super-agent-langchain.js

@@ -1,296 +0,0 @@
-// LangChain adapter for the APX super-agent.
-//
-// Lives alongside the native loop in super-agent.js. Selected via
-// config.super_agent.engine === "langchain" (default: "native"). The two
-// implementations expose the same shape:
-//
-//   { text, usage, name, trace }   ← return value
-//   { globalConfig, projects, plugins, registries, prompt,
-//     previousMessages, contextNote, onEvent, onToken, signal }   ← input
-//
-// Why a toggle and not a replacement: the native loop carries APX-specific
-// features (pseudo-tool fallback for Ollama 500, ghost-response detection,
-// permission_mode gates wired through tool handlers, identity-block injection,
-// ACK_ONLY_TOOLS streak guard). Re-implementing all of those inside LangChain
-// is a large refactor; meanwhile the toggle lets us A/B both paths and pick
-// the one that actually behaves better with gemma4-class models on the
-// user's hardware.
-//
-// LangChain version compat: written against @langchain/core ^0.3 +
-// langchain ^0.3 + @langchain/anthropic ^0.3 + @langchain/ollama ^0.2.
-//
-// Limitations vs native loop (acknowledged in v1):
-//   - permission_mode confirmations are still enforced inside each tool
-//     handler (they return {error: "requires_confirmation: ..."}), but
-//     the loop has no UI to ask the user mid-run, so confirmable tools
-//     just fail-fast as they do today.
-//   - Pseudo-tool fallback (for Ollama 500 on structured tools) is NOT
-//     implemented here — if the underlying engine fails, the call
-//     propagates. Use engine === "native" for that case.
-
-import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
-import { ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts";
-import { DynamicStructuredTool } from "@langchain/core/tools";
-import { HumanMessage, AIMessage, ToolMessage } from "@langchain/core/messages";
-import { z } from "zod";
-
-import { TOOL_SCHEMAS, makeToolHandlers } from "./super-agent-tools.js";
-import { readIdentity } from "../core/identity.js";
-import { logInfo, logWarn, logError } from "../core/logging.js";
-
-const MAX_ITER_DEFAULT = 15;
-
-// ---------------------------------------------------------------------------
-// JSON-Schema → Zod converter
-// ---------------------------------------------------------------------------
-// LangChain's DynamicStructuredTool wants a Zod schema. APX's tools ship JSON
-// Schema (in the OpenAI function-calling shape). We translate just enough for
-// the parameter types APX actually uses: string, number, boolean, object,
-// array, enum, optional/required. Anything more exotic falls back to z.any().
-function jsonSchemaToZod(schema) {
-  if (!schema || typeof schema !== "object") return z.any();
-  // OpenAI function shape: { type: "function", function: { parameters: {...} } }
-  const root = schema.function?.parameters || schema.parameters || schema;
-  return objectToZod(root);
-}
-
-function objectToZod(obj) {
-  if (!obj || obj.type !== "object" || !obj.properties) {
-    return z.object({}).passthrough();
-  }
-  const required = new Set(obj.required || []);
-  const shape = {};
-  for (const [key, prop] of Object.entries(obj.properties)) {
-    let s = propToZod(prop);
-    if (!required.has(key)) s = s.optional();
-    if (prop?.description) s = s.describe(prop.description);
-    shape[key] = s;
-  }
-  return z.object(shape);
-}
-
-function propToZod(prop) {
-  if (!prop || typeof prop !== "object") return z.any();
-  if (Array.isArray(prop.enum) && prop.enum.length > 0) {
-    return z.enum(prop.enum);
-  }
-  switch (prop.type) {
-    case "string":  return z.string();
-    case "number":  return z.number();
-    case "integer": return z.number().int();
-    case "boolean": return z.boolean();
-    case "array":   return z.array(prop.items ? propToZod(prop.items) : z.any());
-    case "object":  return objectToZod(prop);
-    default:        return z.any();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// APX tool → LangChain DynamicStructuredTool
-// ---------------------------------------------------------------------------
-function buildLangChainTools(handlers, schemas, { trace, onEvent }) {
-  return schemas.map((s) => {
-    const name = s.function.name;
-    const handler = handlers[name];
-    if (!handler) {
-      logWarn("super-agent-lc", `no handler for tool ${name} — skipping`);
-      return null;
-    }
-    return new DynamicStructuredTool({
-      name,
-      description: s.function.description || "",
-      schema: jsonSchemaToZod(s),
-      func: async (args) => {
-        const traceId = `lc:${trace.length + 1}`;
-        if (typeof onEvent === "function") {
-          try {
-            await onEvent({
-              type: "tool_start",
-              trace: { id: traceId, tool: name, args, pending: true },
-            });
-          } catch {}
-        }
-        try {
-          const result = await handler(args || {});
-          trace.push({ id: traceId, tool: name, args, result });
-          if (typeof onEvent === "function") {
-            try { await onEvent({ type: "tool_result", trace: { id: traceId, tool: name, args, result } }); } catch {}
-          }
-          return typeof result === "string" ? result : JSON.stringify(result);
-        } catch (e) {
-          const errObj = { error: e.message };
-          trace.push({ id: traceId, tool: name, args, result: errObj });
-          if (typeof onEvent === "function") {
-            try { await onEvent({ type: "tool_result", trace: { id: traceId, tool: name, args, result: errObj } }); } catch {}
-          }
-          return JSON.stringify(errObj);
-        }
-      },
-    });
-  }).filter(Boolean);
-}
-
-// ---------------------------------------------------------------------------
-// Engine factory — picks an @langchain ChatModel based on modelId
-// ---------------------------------------------------------------------------
-async function makeLangChainModel(modelId, config) {
-  // modelId grammar matches engines/index.js: "<provider>:<model>" or
-  // an inferable bare model id ("claude-…" → anthropic, etc).
-  const [providerRaw, ...rest] = String(modelId || "").split(":");
-  let provider = providerRaw.toLowerCase();
-  let model = rest.join(":");
-  if (!model) {
-    // bare id — infer like engines/index.js
-    if (/^claude/i.test(providerRaw)) { provider = "anthropic"; model = providerRaw; }
-    else if (/^gpt|^o[134]/i.test(providerRaw)) { provider = "openai"; model = providerRaw; }
-    else if (/^gemini/i.test(providerRaw)) { provider = "gemini"; model = providerRaw; }
-    else { provider = "ollama"; model = providerRaw; }
-  }
-  const providerCfg = (config && config.engines && config.engines[provider]) || {};
-
-  if (provider === "anthropic") {
-    const { ChatAnthropic } = await import("@langchain/anthropic");
-    const apiKey = providerCfg.api_key || process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) throw new Error("anthropic: no api_key set");
-    return new ChatAnthropic({ apiKey, model, temperature: 1.0, maxTokens: 1024 });
-  }
-  if (provider === "ollama") {
-    const { ChatOllama } = await import("@langchain/ollama");
-    const baseUrl = providerCfg.base_url || process.env.OLLAMA_HOST || "http://localhost:11434";
-    return new ChatOllama({ baseUrl, model, temperature: 0.7 });
-  }
-  if (provider === "openai") {
-    // Lazy import — only required if the user picks openai.
-    const { ChatOpenAI } = await import("@langchain/openai").catch(() => ({}));
-    if (!ChatOpenAI) throw new Error("openai: install @langchain/openai to use this provider with the langchain engine");
-    const apiKey = providerCfg.api_key || process.env.OPENAI_API_KEY;
-    if (!apiKey) throw new Error("openai: no api_key set");
-    return new ChatOpenAI({ apiKey, model, temperature: 1.0 });
-  }
-  throw new Error(`langchain engine: unknown provider "${provider}" (modelId="${modelId}")`);
-}
-
-// ---------------------------------------------------------------------------
-// Convert APX "previousMessages" rows ({role, content}) → LangChain messages
-// ---------------------------------------------------------------------------
-function toLangChainHistory(previousMessages) {
-  return (previousMessages || []).map((m) => {
-    if (m.role === "user")      return new HumanMessage(m.content || "");
-    if (m.role === "assistant") return new AIMessage(m.content || "");
-    if (m.role === "tool") {
-      // LangChain ToolMessage requires a tool_call_id; APX doesn't track ids
-      // in the FS history, so we use a synthetic one. The agent only sees
-      // the content anyway.
-      return new ToolMessage({ content: m.content || "", tool_call_id: m.tool_name || "tool" });
-    }
-    return new HumanMessage(m.content || "");
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Public entry — same contract as runSuperAgent in super-agent.js
-// ---------------------------------------------------------------------------
-export async function runSuperAgentLangChain({
-  globalConfig,
-  projects,
-  plugins,
-  registries,
-  prompt,
-  previousMessages = [],
-  contextNote = "",
-  systemOverride = null,
-  onEvent,
-  onToken,
-  signal,
-}) {
-  const sa = globalConfig?.super_agent || {};
-  if (!sa.model) throw new Error("super-agent (langchain): no model configured");
-
-  const identity = (() => { try { return readIdentity(); } catch { return null; } })();
-  const userLang = globalConfig?.user?.language || "en";
-
-  // System prompt — we reuse the native module's DEFAULT_SYSTEM unless the
-  // caller passes systemOverride. This keeps the personality / language /
-  // hard-rules consistent across both engines.
-  const { DEFAULT_SYSTEM, buildIdentityBlock } = await import("./super-agent.js");
-  const identityBlock = buildIdentityBlock(identity, userLang);
-  const systemPieces = [
-    systemOverride || sa.system || DEFAULT_SYSTEM,
-    identityBlock,
-    contextNote,
-  ].filter(Boolean);
-  // LangChain ChatPromptTemplate uses f-string formatting and will try to
-  // resolve any `{name}` it finds in the system text as an input variable.
-  // The APX prompt naturally contains literal `{path: <CWD>}` examples and
-  // JSON-like snippets, so we double every `{` and `}` to escape them.
-  const systemText = systemPieces.join("\n\n").replace(/[{}]/g, (c) => c + c);
-
-  const trace = [];
-  const handlers = makeToolHandlers({
-    projects, plugins, registries, globalConfig,
-    implicitConfirmation: false,
-  });
-  const tools = buildLangChainTools(handlers, TOOL_SCHEMAS, { trace, onEvent });
-
-  logInfo("super-agent-lc", "starting AgentExecutor", {
-    model: sa.model, tools: tools.length, prev: previousMessages.length,
-  });
-
-  const llm = await makeLangChainModel(sa.model, globalConfig);
-
-  const promptTemplate = ChatPromptTemplate.fromMessages([
-    ["system", systemText],
-    new MessagesPlaceholder("chat_history"),
-    ["human", "{input}"],
-    new MessagesPlaceholder("agent_scratchpad"),
-  ]);
-
-  const agent = await createToolCallingAgent({ llm, tools, prompt: promptTemplate });
-
-  const executor = new AgentExecutor({
-    agent,
-    tools,
-    maxIterations: Number(sa.max_iterations) > 0 ? Number(sa.max_iterations) : MAX_ITER_DEFAULT,
-    returnIntermediateSteps: true,
-    handleParsingErrors: true,
-    // verbose is noisy; we already log via core/logging.js
-  });
-
-  const t0 = Date.now();
-  let result;
-  try {
-    if (typeof onEvent === "function") {
-      try { await onEvent({ type: "model_start", iteration: 1 }); } catch {}
-    }
-    result = await executor.invoke({
-      input: prompt,
-      chat_history: toLangChainHistory(previousMessages),
-    }, { signal });
-  } catch (e) {
-    logError("super-agent-lc", `executor failed in ${Date.now() - t0}ms`, { error: e.message });
-    throw e;
-  }
-
-  // result.output is the final text. result.intermediateSteps is an array
-  // of { action, observation }; we already pushed each into `trace` from the
-  // DynamicStructuredTool wrappers, so we don't double-record them here.
-  const text = String(result.output || "");
-  logInfo("super-agent-lc", `done in ${Date.now() - t0}ms`, {
-    text_len: text.length,
-    tool_calls: trace.length,
-  });
-
-  return {
-    text,
-    // LangChain doesn't surface token counts uniformly across providers;
-    // leave 0/0 so the caller's bookkeeping doesn't break. Real values
-    // would require provider-specific callback handlers.
-    usage: { input_tokens: 0, output_tokens: 0 },
-    name: sa.name || "apx",
-    trace,
-  };
-}
-
-export function isLangChainEngineSelected(cfg) {
-  return cfg?.super_agent?.engine === "langchain";
-}