@aion0/forge 0.8.4 → 0.8.6

package/components/SkillsPanel.tsx

@@ -142,7 +142,7 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
   const [syncing, setSyncing] = useState(false);
   const [loading, setLoading] = useState(true);
   const [installTarget, setInstallTarget] = useState<{ skill: string; show: boolean }>({ skill: '', show: false });
-  const [typeFilter, setTypeFilter] = useState<'all' | 'skill' | 'command' | 'local' | 'rules' | 'plugins' | 'connectors' | 'crafts'>('all');
+  const [typeFilter, setTypeFilter] = useState<'all' | 'skill' | 'command' | 'local' | 'rules' | 'plugins' | 'connectors' | 'crafts' | 'recipes' | 'pipelines'>('all');
   const [localItems, setLocalItems] = useState<{ name: string; type: string; scope: string; fileCount: number; projectPath?: string }[]>([]);
   // Rules (CLAUDE.md templates)
   const [rulesTemplates, setRulesTemplates] = useState<{ id: string; name: string; description: string; tags: string[]; builtin: boolean; isDefault: boolean; content: string }[]>([]);
@@ -174,8 +174,15 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
       setSkills(data.skills || []);
       setProjects(data.projects || []);
       const localData = await localRes.json();
-      // Filter out items already in registry
-      const registryNames = new Set((data.skills || []).map((s: any) => s.name));
+      // Hide filesystem items that match a *synced* registry row (those
+      // belong to the registry list). Uploaded items (source='local')
+      // are intentionally not in this set so they appear under "Local"
+      // — that's where users expect to find what they just uploaded.
+      const registryNames = new Set(
+        (data.skills || [])
+          .filter((s: any) => s.source !== 'local')
+          .map((s: any) => s.name)
+      );
       setLocalItems((localData.items || []).filter((i: any) => !registryNames.has(i.name)));
     } catch {}
     setLoading(false);
@@ -247,6 +254,17 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
     try {
       const fd = new FormData();
       fd.append('file', file);
+      // Use the upload filename as the default install name. Without
+      // this, the server falls back to frontmatter / wrapper-dir name,
+      // which can silently clobber an unrelated skill (e.g. uploading
+      // prelude-nac.zip whose wrapper dir is `prelude/` would overwrite
+      // the registry-synced `prelude`).
+      const baseName = file.name
+        .replace(/\.(md|zip)$/i, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]/g, '-')
+        .replace(/^-+|-+$/g, '');
+      if (/^[a-z0-9][a-z0-9_-]*$/.test(baseName)) fd.append('name', baseName);
       const r = await fetch('/api/skills/install-local', { method: 'POST', body: fd });
       const j = await r.json();
       if (!r.ok || j.ok === false) {
@@ -254,6 +272,7 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
         return;
       }
       await fetchSkills();
+      alert(`Uploaded as "${j.name}" → ${j.target}`);
     } catch (e) {
       alert(`Upload failed: ${e instanceof Error ? e.message : String(e)}`);
     } finally { setUploading(false); }
@@ -352,6 +371,7 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
   // Filter by project, type, and search
   const q = searchQuery.toLowerCase();
   const filtered = (typeFilter === 'local' ? [] : skills
+    .filter(s => s.source !== 'local') // local-uploaded skills render under the Local section instead
     .filter(s => projectFilter ? (s.installedGlobal || s.installedProjects.includes(projectFilter)) : true)
     .filter(s => typeFilter === 'all' ? true : s.type === typeFilter)
     .filter(s => !q || s.name.toLowerCase().includes(q) || s.displayName.toLowerCase().includes(q) || s.description.toLowerCase().includes(q)
@@ -394,21 +414,31 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
       <div className="flex items-center justify-between px-4 py-2 border-b border-[var(--border)] shrink-0">
         <div className="flex items-center gap-2">
           <span className="text-xs font-semibold text-[var(--text-primary)]">Marketplace</span>
-          <div className="flex items-center bg-[var(--bg-tertiary)] rounded p-0.5">
-            {([['all', `All (${skills.length})`], ['skill', `Skills (${skillCount})`], ['command', `Commands (${commandCount})`], ['local', `Local (${localCount})`], ['rules', 'Rules'], ['plugins', 'Plugins'], ['connectors', 'Connectors'], ['crafts', 'Crafts']] as const).map(([value, label]) => (
-              <button
-                key={value}
-                onClick={() => setTypeFilter(value)}
-                className={`text-[9px] px-2 py-0.5 rounded transition-colors ${
-                  typeFilter === value
-                    ? 'bg-[var(--bg-secondary)] text-[var(--text-primary)] shadow-sm'
-                    : 'text-[var(--text-secondary)] hover:text-[var(--text-primary)]'
-                }`}
-              >
-                {label}
-              </button>
-            ))}
-          </div>
+          {/* Grouped category dropdown — replaces the long inline tab bar.
+              Native <optgroup> gives free keyboard nav + a coherent layout
+              regardless of category count. */}
+          <select
+            value={typeFilter}
+            onChange={(e) => setTypeFilter(e.target.value as typeof typeFilter)}
+            className="text-[10px] px-2 py-1 rounded bg-[var(--bg-tertiary)] border border-[var(--border)] text-[var(--text-primary)] focus:outline-none focus:border-[var(--accent)]"
+          >
+            <optgroup label="Catalog">
+              <option value="all">All ({skills.length})</option>
+              <option value="skill">Skills ({skillCount})</option>
+              <option value="command">Commands ({commandCount})</option>
+              <option value="local">Local ({localCount})</option>
+              <option value="rules">Rules</option>
+            </optgroup>
+            <optgroup label="Extensions">
+              <option value="plugins">Plugins</option>
+              <option value="connectors">Connectors</option>
+              <option value="crafts">Crafts</option>
+            </optgroup>
+            <optgroup label="Templates">
+              <option value="recipes">Recipes</option>
+              <option value="pipelines">Pipelines</option>
+            </optgroup>
+          </select>
         </div>
         <span className="text-[8px] px-1.5 py-0.5 rounded bg-blue-500/15 text-blue-400">Claude Code</span>
         <input
@@ -426,7 +456,7 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
           type="button"
           onClick={() => skillUploadRef.current?.click()}
           disabled={uploading}
-          title="Upload a local skill — SKILL.md or a .zip bundle. Falls outside the forge-skills registry."
+          title="Upload your own skill — SKILL.md or a .zip bundle. Stored locally, not synced from the marketplace."
           className="text-[9px] text-[var(--text-secondary)] hover:text-[var(--text-primary)] disabled:opacity-50"
         >
           {uploading ? 'Uploading…' : '+ Upload'}
@@ -450,7 +480,7 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
         />
       </div>}
 
-      {typeFilter === 'rules' || typeFilter === 'plugins' || typeFilter === 'connectors' || typeFilter === 'crafts' ? null : skills.length === 0 ? (
+      {typeFilter === 'rules' || typeFilter === 'plugins' || typeFilter === 'connectors' || typeFilter === 'crafts' || typeFilter === 'recipes' || typeFilter === 'pipelines' ? null : skills.length === 0 ? (
         <div className="flex-1 flex flex-col items-center justify-center gap-2 text-[var(--text-secondary)]">
           <p className="text-xs">No skills yet</p>
           <button onClick={sync} className="text-xs px-3 py-1 bg-[var(--accent)] text-white rounded hover:opacity-90">
@@ -501,8 +531,10 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
                 </div>
               );
             })}
-            {/* Local items — collapsible by scope group */}
-            {(typeFilter === 'all' || typeFilter === 'local') && filteredLocal.length > 0 && (
+            {/* Local items — collapsible by scope group. Visible on
+                All/Local AND on Skills/Commands so uploaded items show
+                up under their own type tab too. */}
+            {(typeFilter === 'all' || typeFilter === 'local' || typeFilter === 'skill' || typeFilter === 'command') && filteredLocal.length > 0 && (
               <>
                 {/* Local section header — collapsible */}
                 {typeFilter !== 'local' && (
@@ -1041,6 +1073,130 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
           <CraftsMarketplacePanelLazy searchQuery={searchQuery} />
         </Suspense>
       )}
+
+      {/* Recipes / Pipelines — read-only marketplace browser. Actual
+          use lives in extension's Jobs tab (recipes) and Pipelines tab
+          (pipelines): both show the same registry data with a "create
+          local copy / instantiate" action. This page exists for
+          discovery only. */}
+      {(typeFilter === 'recipes' || typeFilter === 'pipelines') && (
+        <WorkflowMarketplaceBrowser kind={typeFilter === 'recipes' ? 'recipe' : 'pipeline'} searchQuery={searchQuery} />
+      )}
+    </div>
+  );
+}
+
+// ─── Workflow Marketplace browser (read-only) ────────────────
+// Pulls /api/workflows/marketplace and renders recipes or pipelines.
+// Each row links to where you'd actually use it; no Install button here
+// because the use flow (Jobs/Pipelines tab) handles install implicitly.
+
+interface MarketRow {
+  kind: 'recipe' | 'pipeline';
+  name: string;
+  display_name: string;
+  description?: string;
+  version: string;
+  author?: string;
+  tags?: string[];
+  source: 'registry' | 'local';
+  installed: boolean;
+  installed_version?: string;
+  has_update?: boolean;
+}
+
+function WorkflowMarketplaceBrowser({ kind, searchQuery }: { kind: 'recipe' | 'pipeline'; searchQuery: string }) {
+  const [rows, setRows] = useState<MarketRow[] | null>(null);
+  const [busy, setBusy] = useState(false);
+  const [err, setErr] = useState<string>('');
+
+  const useInLocation = kind === 'recipe' ? 'Jobs tab' : 'Pipelines tab';
+
+  const load = async () => {
+    try {
+      const res = await fetch('/api/workflows/marketplace');
+      const data = await res.json();
+      setRows((kind === 'recipe' ? data.recipes : data.pipelines) || []);
+    } catch (e) {
+      setErr(e instanceof Error ? e.message : String(e));
+      setRows([]);
+    }
+  };
+
+  const sync = async () => {
+    setBusy(true);
+    setErr('');
+    try {
+      const res = await fetch('/api/workflows/marketplace', {
+        method: 'POST', headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'sync' }),
+      });
+      const data = await res.json();
+      if (!data.ok) setErr(data.error || 'sync failed');
+      await load();
+    } catch (e) { setErr(e instanceof Error ? e.message : String(e)); }
+    finally { setBusy(false); }
+  };
+
+  useEffect(() => { void load(); }, [kind]);
+
+  const q = searchQuery.toLowerCase();
+  const filtered = (rows || []).filter(r => !q
+    || r.name.toLowerCase().includes(q)
+    || r.display_name.toLowerCase().includes(q)
+    || (r.description || '').toLowerCase().includes(q)
+    || (r.tags || []).some(t => t.toLowerCase().includes(q)));
+
+  return (
+    <div className="flex-1 flex flex-col min-h-0 overflow-y-auto">
+      <div className="px-4 py-2 border-b border-[var(--border)] flex items-center gap-2 shrink-0">
+        <span className="text-[10px] text-[var(--text-secondary)] flex-1">
+          {kind === 'recipe' ? 'Job recipes' : 'Pipeline templates'} from <code className="font-mono">aiwatching/forge-workflow</code>
+          {' · '}use them from the {useInLocation}
+        </span>
+        <button
+          onClick={() => void sync()}
+          disabled={busy}
+          className="text-[9px] px-2 py-1 border border-[var(--border)] text-[var(--text-secondary)] rounded hover:text-[var(--text-primary)] disabled:opacity-50"
+        >{busy ? 'Syncing…' : 'Sync'}</button>
+      </div>
+      {err && (
+        <div className="px-4 py-2 text-[10px] text-[var(--red)] border-b border-[var(--border)]">{err}</div>
+      )}
+      <div className="p-3 space-y-2">
+        {rows == null ? (
+          <div className="text-[11px] text-[var(--text-secondary)] text-center py-8">Loading…</div>
+        ) : filtered.length === 0 ? (
+          <div className="text-[11px] text-[var(--text-secondary)] text-center py-8">
+            {rows.length === 0 ? <>Nothing in the registry yet — click <b>Sync</b>.</> : 'No matches for your search.'}
+          </div>
+        ) : (
+          filtered.map((r) => (
+            <div key={r.name} className="border border-[var(--border)] rounded p-3 bg-[var(--bg-tertiary)]/30">
+              <div className="flex items-baseline gap-2">
+                <span className="text-[11px] font-semibold text-[var(--text-primary)] flex-1">{r.display_name}</span>
+                <span className="text-[8px] text-[var(--text-secondary)] font-mono">v{r.version}</span>
+                {/* Read-only catalog — no install/uninstall here; usage
+                    happens in Jobs / Pipelines tab and that's where the
+                    install state matters. */}
+                {r.source === 'local' && <span className="text-[8px] text-[var(--text-secondary)]" title="Only on this machine — not in the marketplace registry">· local-only</span>}
+              </div>
+              {r.description && (
+                <p className="text-[10px] text-[var(--text-secondary)] mt-1.5 leading-relaxed whitespace-pre-wrap">{r.description}</p>
+              )}
+              <div className="mt-2 flex items-center gap-2">
+                <code className="text-[9px] text-[var(--text-secondary)] font-mono">{r.name}</code>
+                {r.author && <span className="text-[9px] text-[var(--text-secondary)]">· {r.author}</span>}
+                {r.tags && r.tags.length > 0 && (
+                  <span className="text-[9px] text-[var(--text-secondary)]">{r.tags.map(t => `#${t}`).join(' ')}</span>
+                )}
+                <span className="flex-1" />
+                <span className="text-[9px] text-[var(--text-secondary)] italic">Use in {useInLocation} →</span>
+              </div>
+            </div>
+          ))
+        )}
+      </div>
     </div>
   );
 }

package/components/WorkspaceView.tsx

@@ -726,7 +726,9 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
   const [pluginDefs, setPluginDefs] = useState<{ id: string; name: string; icon: string }[]>([]);
 
   useEffect(() => {
-    fetch('/api/agents').then(r => r.json()).then(data => {
+    // WorkspaceView shows BOTH CLI agents and API profiles (workspace
+    // agents can run in either backend), so opt into ?include=all.
+    fetch('/api/agents?include=all').then(r => r.json()).then(data => {
       const list = (data.agents || data || []).map((a: any) => ({
         id: a.id, name: a.name || a.id,
         isProfile: a.isProfile || a.base,

package/install.sh

@@ -47,6 +47,34 @@ if ! command -v claude >/dev/null 2>&1 \
   echo ""
 fi
 
+# Optional helpers used by built-in workflows. Warn-only — Forge installs
+# fine without them, but specific pipelines will fail at the shell step
+# if they're missing (e.g. mr-review-fix calls glab + jq).
+missing_opts=()
+command -v jq   >/dev/null 2>&1 || missing_opts+=("jq")
+command -v glab >/dev/null 2>&1 || missing_opts+=("glab")
+if [ ${#missing_opts[@]} -gt 0 ]; then
+  echo "[forge] ⚠️  Optional CLIs missing: ${missing_opts[*]}"
+  echo "[forge]    jq   — needed by shell pipelines that parse JSON"
+  echo "[forge]    glab — needed by the mr-review-fix workflow (GitLab API)"
+  case "$(uname -s)" in
+    Darwin)
+      echo "[forge] Install: brew install ${missing_opts[*]}"
+      if command -v brew >/dev/null 2>&1; then
+        read -r -p "[forge] Install now? [y/N] " reply
+        case "$reply" in [yY]*) brew install "${missing_opts[@]}" ;; esac
+      fi
+      ;;
+    Linux)
+      echo "[forge] Install via your distro's package manager."
+      case " ${missing_opts[*]} " in
+        *" glab "*) echo "[forge]    glab — see https://gitlab.com/gitlab-org/cli#installation" ;;
+      esac
+      ;;
+  esac
+  echo ""
+fi
+
 if [ "$1" = "local" ] || [ "$1" = "--local" ]; then
   echo "[forge] Installing from local source..."
   npm uninstall -g @aion0/forge 2>/dev/null || true

package/lib/agents/index.ts

@@ -78,7 +78,12 @@ export function listAgents(): AgentConfig[] {
     for (const [id, cfg] of Object.entries(settings.agents)) {
       if (['claude', 'codex', 'aider'].includes(id)) continue;
 
-      // API profile — no CLI detection needed
+      // API profile — no CLI detection needed. Tagged with
+      // backendType='api' so CLI-only dropdowns (Terminal launcher,
+      // NewTaskModal etc.) can filter them out via
+      // `agents.filter(a => a.backendType !== 'api')`. WorkspaceView's
+      // API mode keeps them visible. Chat backend doesn't go through
+      // this path at all — it reads settings.agents directly.
       if (cfg.type === 'api') {
         agents.push({
           id,

package/lib/chat/agent-loop.ts

@@ -78,11 +78,45 @@ function inferAdapter(provider: string | undefined): 'anthropic' | 'openai' {
   return 'openai';
 }
 
-function pickBaseUrl(profile: { baseUrl?: string; env?: Record<string, string> }, adapter: 'anthropic' | 'openai'): string {
+/**
+ * Provider → default public API URL. Saves the user from having to know
+ * the right host for first-party providers; only LiteLLM (which is by
+ * definition a self-hosted proxy) requires an explicit URL.
+ *
+ * Resolution priority: profile.baseUrl > env.*_BASE_URL > provider default.
+ */
+export function defaultBaseUrl(provider: string | undefined): string {
+  switch ((provider || '').toLowerCase()) {
+    case 'anthropic':
+    case 'claude':
+      return 'https://api.anthropic.com';
+    case 'openai':
+      return 'https://api.openai.com/v1';
+    case 'grok':
+    case 'xai':
+      return 'https://api.x.ai/v1';
+    case 'google':
+    case 'gemini':
+      // Google's Gemini exposes an OpenAI-compatible shim at this path.
+      return 'https://generativelanguage.googleapis.com/v1beta/openai';
+    case 'deepseek':
+      return 'https://api.deepseek.com';
+    default:
+      return '';
+  }
+}
+
+function pickBaseUrl(
+  profile: { baseUrl?: string; env?: Record<string, string>; provider?: string },
+  adapter: 'anthropic' | 'openai',
+): string {
   if (profile.baseUrl) return profile.baseUrl;
   const env = profile.env || {};
-  if (adapter === 'anthropic') return env.ANTHROPIC_BASE_URL || '';
-  return env.OPENAI_BASE_URL || env.OPENAI_API_BASE || '';
+  const envOverride = adapter === 'anthropic'
+    ? env.ANTHROPIC_BASE_URL
+    : (env.OPENAI_BASE_URL || env.OPENAI_API_BASE);
+  if (envOverride) return envOverride;
+  return defaultBaseUrl(profile.provider);
 }
 
 function pickApiKey(profile: { apiKey?: string; env?: Record<string, string> }, adapter: 'anthropic' | 'openai'): string {

package/lib/chat/llm/anthropic.ts

@@ -16,10 +16,13 @@ function historyToApi(history: Message[]): Anthropic.MessageParam[] {
       if (b.type === 'text') {
         if (b.text.length > 0) content.push({ type: 'text', text: b.text });
       } else if (b.type === 'tool_use') {
+        // Same encoding as tool definitions — names with `.` must
+        // round-trip through Anthropic as `__` to satisfy its tool name
+        // regex when this turn's history is re-sent next turn.
         content.push({
           type: 'tool_use',
           id: b.id,
-          name: b.name,
+          name: b.name.replace(/\./g, '__'),
           input: (b.input ?? {}) as Record<string, unknown>,
         });
       } else if (b.type === 'tool_result') {
@@ -64,6 +67,20 @@ export function makeAnthropicClient(apiKey: string, baseUrl: string): Anthropic
   return new Anthropic(opts);
 }
 
+/**
+ * Anthropic restricts tool names to `^[a-zA-Z0-9_-]{1,128}$`. Forge's
+ * connector tools use a `connector.tool` namespace (e.g.
+ * `gitlab.list_my_mrs`), so we encode the dot as `__` on the way out and
+ * decode it back when Anthropic returns a tool_use. Internal dispatcher
+ * still sees the canonical dotted form.
+ */
+function encodeToolName(name: string): string {
+  return name.replace(/\./g, '__');
+}
+function decodeToolName(name: string): string {
+  return name.replace(/__/g, '.');
+}
+
 export const anthropicAdapter: LlmAdapter = {
   async stream(req: LlmRequest, cb: LlmCallbacks): Promise<LlmTurnResult> {
     const client = makeAnthropicClient(req.apiKey, req.baseUrl);
@@ -73,7 +90,7 @@ export const anthropicAdapter: LlmAdapter = {
       max_tokens: req.maxTokens,
       system: req.system,
       tools: req.tools.map((t) => ({
-        name: t.name,
+        name: encodeToolName(t.name),
         description: t.description,
         input_schema: t.input_schema as Anthropic.Tool.InputSchema,
       })),
@@ -89,8 +106,9 @@ export const anthropicAdapter: LlmAdapter = {
       if (block.type === 'text') {
         content.push({ type: 'text', text: block.text });
       } else if (block.type === 'tool_use') {
-        cb.onToolUse({ id: block.id, name: block.name, input: block.input });
-        content.push({ type: 'tool_use', id: block.id, name: block.name, input: block.input });
+        const decodedName = decodeToolName(block.name);
+        cb.onToolUse({ id: block.id, name: decodedName, input: block.input });
+        content.push({ type: 'tool_use', id: block.id, name: decodedName, input: block.input });
       }
     }
 

package/lib/chat/protocols/http.ts

@@ -22,6 +22,13 @@ export interface HttpProtocolArgs {
   tool: ConnectorTool;
   settings: Record<string, any>;
   args: Record<string, any>;
+  /**
+   * When true, return the full response body without the 8KB cap. Used by
+   * the Jobs scheduler — it parses JSON, not feeds the response into an
+   * LLM context, so truncation breaks `JSON.parse` for any response
+   * larger than 8KB (Todos / search responses routinely exceed this).
+   */
+  noTruncation?: boolean;
 }
 
 export interface HttpProtocolResult {
@@ -45,8 +52,39 @@ function expandObjectLeaves(obj: any, settings: Record<string, any>, args: Recor
   return obj;
 }
 
+/**
+ * Expand `{args.X}` placeholders in a URL path with the value URL-
+ * encoded. `{settings.X}` is NOT encoded — `{settings.base_url}` is the
+ * scheme + host (with its own `://` and `/`), which must stay literal.
+ *
+ * Why: GitLab and many REST APIs accept either a numeric id or a
+ * URL-encoded namespace path (`fortinac%2FFortiNAC`) as the project
+ * identifier in the path. Without encoding, `args.project_id =
+ * "fortinac/FortiNAC"` interpolates as a raw `/` and turns
+ * `/projects/{args.project_id}/...` into `/projects/fortinac/FortiNAC/...`
+ * (extra path segment), which the API can't parse. Numeric ids encode
+ * to themselves — no regression.
+ */
+function expandUrlPath(template: string, settings: Record<string, any>, args: Record<string, any>): string {
+  // First handle settings.* with raw substitution (keeps base_url intact).
+  let out = expandAllTokens(template, settings, {});
+  // Then handle args.* with URL-encoding.
+  out = out.replace(/\{args\.([^{}]+)\}/g, (full, rawKey) => {
+    const path = String(rawKey).trim().split('.');
+    let v: any = args;
+    for (const p of path) {
+      if (v == null || typeof v !== 'object') { v = undefined; break; }
+      v = v[p];
+    }
+    if (v == null) return full;
+    const s = typeof v === 'string' ? v : (typeof v === 'number' || typeof v === 'boolean' ? String(v) : JSON.stringify(v));
+    return encodeURIComponent(s);
+  });
+  return out;
+}
+
 function buildUrl(spec: HttpRequestSpec, settings: Record<string, any>, args: Record<string, any>): string {
-  const base = expandAllTokens(spec.url, settings, args);
+  const base = expandUrlPath(spec.url, settings, args);
   if (!spec.query) return base;
   const url = new URL(base);
   for (const [k, raw] of Object.entries(spec.query)) {
@@ -86,7 +124,7 @@ function truncate(s: string): { text: string; truncated: boolean; totalBytes: nu
   return { text: slice, truncated: true, totalBytes: buf.byteLength };
 }
 
-export async function runHttp({ tool, settings, args }: HttpProtocolArgs): Promise<HttpProtocolResult> {
+export async function runHttp({ tool, settings, args, noTruncation }: HttpProtocolArgs): Promise<HttpProtocolResult> {
   const spec = tool.request;
   if (!spec || !spec.url) {
     return { content: 'http tool missing `request.url`', is_error: true };
@@ -125,6 +163,12 @@ export async function runHttp({ tool, settings, args }: HttpProtocolArgs): Promi
   clearTimeout(timer);
 
   const text = await res.text().catch(() => '');
+  if (noTruncation) {
+    // Jobs scheduler / preview path — return the body verbatim so
+    // JSON.parse works on responses larger than MAX_BODY_BYTES. No
+    // preamble either; callers parse content directly.
+    return { content: text, is_error: !res.ok };
+  }
   const { text: shown, truncated, totalBytes } = truncate(text);
   const preamble = `HTTP ${res.status} ${res.statusText} · ${method} ${url}\n` +
                    (truncated ? `(showing ${MAX_BODY_BYTES} of ${totalBytes} bytes — truncated)\n\n` : '\n');

package/lib/chat/tool-dispatcher.ts

@@ -130,11 +130,29 @@ function buildConnectorPayload(
 
 // ─── Public entry ─────────────────────────────────────────
 
+export interface DispatchOptions {
+  /** Per-turn extra builtins (e.g. memory_* when Temper is configured). */
+  extraBuiltins?: Record<string, BuiltinHandler>;
+  /**
+   * Skip the HTTP-protocol 8KB body cap. Set by callers that parse the
+   * response programmatically (Jobs scheduler, /api/jobs/preview) and
+   * therefore don't need an LLM-friendly truncation.
+   */
+  noTruncation?: boolean;
+}
+
 export async function dispatchTool(
   call: ToolCall,
-  /** Per-turn extra builtins (e.g. memory_* when Temper is configured). */
-  extraBuiltins?: Record<string, BuiltinHandler>,
+  optsOrExtraBuiltins?: DispatchOptions | Record<string, BuiltinHandler>,
 ): Promise<ToolResult> {
+  // Back-compat: accept either DispatchOptions or a bare extraBuiltins map
+  // so older callers (chat agent-loop etc.) keep working without edits.
+  const opts: DispatchOptions = optsOrExtraBuiltins && 'extraBuiltins' in (optsOrExtraBuiltins as any)
+    ? (optsOrExtraBuiltins as DispatchOptions)
+    : optsOrExtraBuiltins && 'noTruncation' in (optsOrExtraBuiltins as any)
+      ? (optsOrExtraBuiltins as DispatchOptions)
+      : { extraBuiltins: optsOrExtraBuiltins as Record<string, BuiltinHandler> | undefined };
+  const extraBuiltins = opts.extraBuiltins;
   // Per-turn builtins first (memory tools), then global builtins.
   const dynBuiltin = extraBuiltins?.[call.name];
   if (dynBuiltin) {
@@ -164,7 +182,7 @@ export async function dispatchTool(
   try {
     switch (protocol) {
       case 'http':
-        return await runHttp({ tool: located.tool, settings: located.settings, args: argInput });
+        return await runHttp({ tool: located.tool, settings: located.settings, args: argInput, noTruncation: opts.noTruncation });
       case 'shell':
         return await runShell({ tool: located.tool, settings: located.settings, args: argInput });
       case 'browser': {