opencodekit 0.15.19 → 0.15.21

package/dist/template/.opencode/memory/observations/2026-01-31-decision-copilot-auth-plugin-updated-with-baseurl.md

@@ -0,0 +1,63 @@
+---
+type: decision
+created: 2026-01-31T05:13:11.027Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["copilot", "auth", "plugin", "baseURL", "chat.headers", "anthropic-beta", "reasoning", "thinking", "enterprise"]
+---
+
+# 🎯 Copilot Auth Plugin Updated with baseURL and chat.headers
+
+🟢 **Confidence:** high
+
+## Changes Made to copilot-auth.ts
+
+### 1. Added baseURL return for enterprise support
+```typescript
+// Enterprise URL support for baseURL
+const enterpriseUrl = (info as any).enterpriseUrl;
+const baseURL = enterpriseUrl
+  ? `https://copilot-api.${normalizeDomain(enterpriseUrl)}`
+  : undefined;
+
+return {
+  baseURL,  // ← Now returned
+  apiKey: "",
+  // ...
+}
+```
+
+### 2. Added chat.headers hook for Claude reasoning support
+```typescript
+"chat.headers": async (input: any, output: any) => {
+  // Only apply to GitHub Copilot provider
+  if (!input.model?.providerID?.includes("github-copilot")) return;
+
+  // Add Anthropic beta header for interleaved thinking (extended reasoning)
+  if (input.model?.api?.npm === "@ai-sdk/anthropic") {
+    output.headers["anthropic-beta"] = "interleaved-thinking-2025-05-14";
+  }
+
+  // Mark subagent sessions as agent-initiated
+  const session = await sdk.session.get(...);
+  if (session?.data?.parentID) {
+    output.headers["x-initiator"] = "agent";
+  }
+}
+```
+
+### Why These Changes Matter
+
+1. **baseURL**: Enterprise users using GitHub Enterprise with data residency will now get correct API routing to `copilot-api.<domain>`.
+
+2. **anthropic-beta header**: When Claude routing is re-enabled (the commented-out code), this header will be automatically added to enable extended thinking/reasoning. The header `interleaved-thinking-2025-05-14` is required for Claude to return thinking blocks.
+
+3. **Subagent x-initiator**: Sessions that are children of other sessions (subagents) will be marked as `agent` initiated, matching the standard that other Copilot tools use.
+
+### Note on Reasoning Activation
+
+The anthropic-beta header only activates when:
+- `input.model.api.npm === "@ai-sdk/anthropic"`
+
+Currently, all models use `@ai-sdk/github-copilot`, so the header won't be added until the commented Claude routing code is re-enabled.

package/dist/template/.opencode/memory/observations/2026-01-31-decision-created-dedicated-worker-agent-for-swarm.md

@@ -0,0 +1,20 @@
+---
+type: decision
+created: 2026-01-31T13:42:23.877Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["worker", "swarm", "tmux", "agent", "spawn_session", "primary", "subagent"]
+---
+
+# 🎯 Created dedicated worker agent for swarm
+
+🟢 **Confidence:** high
+
+Created a new `worker` agent (primary mode) specifically for tmux-spawned swarm tasks. This keeps `general` as a subagent (for Task tool delegation) while providing a standalone agent that can be spawned via `opencode run --agent worker`.
+
+Key differences:
+- worker: mode=primary, can run standalone, focused on delegated task execution
+- general: mode=subagent, only via Task tool, fast small tasks
+
+The tmux tool now defaults to `agent: "worker"` for spawn_session operations.

package/dist/template/.opencode/memory/observations/2026-01-31-decision-rollback-to-v1-1-47-for-copilot-claude-r.md

@@ -0,0 +1,21 @@
+---
+type: decision
+created: 2026-01-31T17:20:18.779Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["copilot", "claude", "reasoning", "thinking_budget", "rollback", "v1.1.47", "signature validation"]
+---
+
+# 🎯 Rollback to v1.1.47 for Copilot Claude reasoning
+
+🟢 **Confidence:** high
+
+User decided to rollback to OpenCode v1.1.47 approach instead of waiting for PR #8958 to merge. The v1.1.48+ native SDK has "Invalid signature in thinking block" errors with Claude models via GitHub Copilot.
+
+Rollback includes:
+1. Restore copilot-auth.ts with thinking_budget injection (from commit 6f003b5)
+2. Restore custom SDK at .opencode/plugin/sdk/copilot/ with reasoning_text/reasoning_opaque handling
+3. Restore opencode.json github-copilot provider config with reasoning: true for Claude models
+
+This custom SDK bypasses native signature validation but provides working extended thinking.

package/dist/template/.opencode/memory/observations/2026-01-31-decision-simplified-swarm-to-task-tool-pattern.md

@@ -0,0 +1,44 @@
+---
+type: decision
+created: 2026-01-31T18:41:11.898Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["swarm", "task-tool", "parallel-execution", "mailbox", "simplification"]
+files: [".opencode/tool/swarm-monitor.ts", ".opencode/tool/swarm-delegate.ts", ".opencode/plugin/swarm-enforcer.ts", ".opencode/agent/build.md"]
+---
+
+# 🎯 Simplified swarm to Task tool pattern
+
+🟢 **Confidence:** high
+
+## Decision
+Removed mailbox complexity from swarm system. The Task tool handles agent lifecycle and result collection natively.
+
+## Changes Made
+1. **swarm-monitor.ts**: Removed mail_send, mail_read, persist_todos, restore_todos, get_todos. Now only has progress_update, progress_render, render_block, status, clear.
+2. **swarm-delegate.ts**: Updated example to remove swarm-monitor references
+3. **swarm-enforcer.ts**: Renamed from "SWARM PROTOCOL" to "BEADS PROTOCOL", simplified messaging
+4. **build.md agent**: Dramatically simplified - removed complex PARL workflow, tmux panes, mailbox monitoring. Now focuses on Task tool pattern.
+5. **Removed files**: tmux.ts, worker.md (no longer needed)
+
+## Why
+- Task tool already handles results returning to parent
+- OpenCode manages agent lifecycle automatically
+- Mailbox was adding complexity without value
+- Session navigation (ctrl+alt+left/right) provides visibility
+
+## New Pattern
+```typescript
+// Simple parallel execution
+Task({ subagent_type: "explore", prompt: "Find X..." });
+Task({ subagent_type: "general", prompt: "Implement Y..." });
+// Results return directly - no mailbox needed
+```
+
+## Files Affected
+- .opencode/tool/swarm-monitor.ts
+- .opencode/tool/swarm-delegate.ts
+- .opencode/plugin/swarm-enforcer.ts
+- .opencode/agent/build.md
+- dist/template/* (all synced)

package/dist/template/.opencode/memory/observations/2026-01-31-decision-swarm-architecture-task-tool-over-tmux.md

@@ -0,0 +1,33 @@
+---
+type: decision
+created: 2026-01-31T18:34:23.413Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["swarm", "task-tool", "child-session", "parallel", "architecture", "simplify"]
+---
+
+# 🎯 Swarm architecture: Task tool over tmux
+
+🟢 **Confidence:** high
+
+Decided to use Task tool (child sessions) instead of tmux-spawned orphan sessions for swarm coordination.
+
+Reasons:
+1. Task tool manages lifecycle automatically - no orphaned processes
+2. Results return directly to parent - no mailbox communication needed
+3. Built-in session navigation (ctrl+alt+right/left) for visibility
+4. Simpler architecture - no process management complexity
+
+Removed:
+- worker agent (.opencode/agent/worker.md)
+- tmux tool (.opencode/tool/tmux.ts)
+- swarm-monitor mailbox complexity
+
+Pattern for parallel work:
+```typescript
+// Launch parallel subagents - results return to parent
+Task({ subagent_type: "general", prompt: "Task 1..." });
+Task({ subagent_type: "explore", prompt: "Task 2..." });
+// Navigate to child sessions: ctrl+alt+right/left
+```

package/dist/template/.opencode/memory/observations/2026-01-31-decision-worker-skills-defined-for-swarm-delegati.md

@@ -0,0 +1,30 @@
+---
+type: decision
+created: 2026-01-31T19:09:09.501Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["swarm", "delegation", "worker skills", "verification", "TDD", "tool priority"]
+---
+
+# 🎯 Worker skills defined for swarm delegation
+
+🟢 **Confidence:** high
+
+Updated swarm-delegate and swarm-plan tools to recommend essential skills for worker agents:
+
+Required/Recommended skills for workers:
+1. verification-before-completion - REQUIRED: Workers must verify before claiming done
+2. test-driven-development - RECOMMENDED: Write tests first, watch fail, implement, verify pass  
+3. tool-priority - RECOMMENDED: Use LSP before edits, grep for patterns, read before edit
+
+Changes made:
+- swarm-delegate.ts: Added "Recommended skills for workers" section to tool description
+- swarm-plan.ts: Added "Worker skills" section with skill() calls to load
+
+These skills ensure workers:
+- Follow proper verification protocol (no false "done" claims)
+- Use TDD for quality implementation
+- Use correct tool priority (LSP before edits)
+
+Both tools synced to dist/template/.

package/dist/template/.opencode/memory/observations/2026-01-31-learning-gpt-reasoning-config-for-github-copilot.md

@@ -0,0 +1,51 @@
+---
+type: learning
+created: 2026-01-31T18:13:49.325Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["opencode", "gpt", "reasoning", "github-copilot", "model-config", "variants", "reasoningEffort"]
+---
+
+# 📚 GPT reasoning config for GitHub Copilot
+
+🟢 **Confidence:** high
+
+## GPT Models Reasoning Configuration on GitHub Copilot Provider
+
+For OpenAI GPT models (gpt-5.2, gpt-5.2-codex) via github-copilot provider, reasoning is configured using these options:
+
+### Key Options
+- `reasoningEffort`: "low" | "medium" | "high" - Controls reasoning depth
+- `reasoningSummary`: "auto" | "always" | "never" - Show reasoning summary
+- `textVerbosity`: "low" | "medium" | "high" - Controls output verbosity
+- `include`: ["reasoning.encrypted_content"] - Include encrypted reasoning
+
+### Configuration Structure
+```json
+"github-copilot": {
+  "models": {
+    "gpt-5.2": {
+      "reasoning": true,
+      "options": {
+        "reasoningEffort": "medium",
+        "reasoningSummary": "auto"
+      },
+      "variants": {
+        "high": { "reasoningEffort": "high", "include": ["reasoning.encrypted_content"] },
+        "low": { "reasoningEffort": "low" },
+        "medium": { "reasoningEffort": "medium" }
+      }
+    }
+  }
+}
+```
+
+### Usage
+1. Select model: `/models` → choose `github-copilot/gpt-5.2`
+2. Cycle variants: Use keybind to switch between low/medium/high
+3. Or add `--variant high` when starting
+
+### Difference from Claude models
+- Claude uses `thinking_budget` (token count)
+- GPT uses `reasoningEffort` (low/medium/high qualitative levels)

package/dist/template/.opencode/memory/observations/2026-01-31-learning-opencode-copilot-auth-comparison-finding.md

@@ -0,0 +1,61 @@
+---
+type: learning
+created: 2026-01-31T05:04:00.660Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["copilot", "auth", "plugin", "token-refresh", "reasoning", "thinking", "github-copilot", "opencode", "comparison"]
+files: ["index.mjs"]
+---
+
+# 📚 OpenCode Copilot Auth Comparison Findings
+
+🟢 **Confidence:** high
+
+## Key Findings from Comparing Local vs Official OpenCode Copilot Auth Plugin
+
+### Official Plugin Location
+- Repository: `anomalyco/opencode-copilot-auth` (separate repo)
+- File: `index.mjs`
+- The auth.ts in main opencode repo is just auth orchestration, not the actual plugin
+
+### Critical Differences Found
+
+#### 1. CLIENT_ID Mismatch
+- **Local**: `Ov23li8tweQw6odWQebz` 
+- **Official**: `Iv1.b507a08c87ecfe98`
+- CRITICAL: Different OAuth client IDs will affect authentication!
+
+#### 2. Token Refresh Mechanism
+- **Local**: Does NOT refresh Copilot API token - uses OAuth access token directly
+- **Official**: Uses `COPILOT_API_KEY_URL` (`/copilot_internal/v2/token`) to get short-lived Copilot tokens
+- CRITICAL: Local version may have token expiration issues
+
+#### 3. Token Storage
+- **Local**: Stores `data.access_token` as both `refresh` and `access` with `expires: 0`
+- **Official**: Stores OAuth token as `refresh`, and fetches separate Copilot token as `access` with proper expiration
+
+#### 4. Rate Limit Handling
+- **Local**: Has retry logic with exponential backoff for 429 errors
+- **Official**: No retry logic - relies on proper token refresh instead
+
+#### 5. Model Configuration
+- **Local**: Sets `model.api.npm = "@ai-sdk/github-copilot"` explicitly
+- **Official**: Does NOT modify model SDK - lets OpenCode core handle it
+
+#### 6. Agent Detection Logic
+- **Local**: Checks ALL messages for tool/assistant roles
+- **Official**: Only checks LAST message for agent detection
+
+#### 7. baseURL Configuration
+- **Local**: Does NOT set baseURL (commented out Claude routing)
+- **Official**: Sets baseURL dynamically based on enterprise vs public deployment
+
+### Reasoning/Thinking Block Fix Context
+The v1.1.46 fix "Remove AI SDK middleware that was preventing think blocks" is in the core OpenCode provider code, NOT in the copilot auth plugin. The `extractReasoningMiddleware` is used to extract thinking from tags like `<think>`, but Anthropic's native thinking doesn't need this.
+
+### Recommendation
+The local plugin has diverged significantly from official. Key issues:
+1. Wrong CLIENT_ID will cause auth problems
+2. Missing token refresh logic will cause "Not Found" or auth errors
+3. Agent detection differs which affects `x-initiator` header

package/dist/template/.opencode/memory/observations/2026-01-31-learning-opencode-copilot-reasoning-architecture-.md

@@ -0,0 +1,66 @@
+---
+type: learning
+created: 2026-01-31T05:23:35.673Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["copilot", "reasoning", "thinking", "config", "opencode", "sdk", "thinking_budget", "reasoning_text", "reasoning_opaque"]
+---
+
+# 📚 OpenCode Copilot Reasoning Architecture Explained
+
+🟢 **Confidence:** high
+
+## OpenCode Copilot Reasoning Architecture
+
+### Config Parameters Found in opencode.json
+The `github-copilot` provider has Claude models with reasoning configured:
+```json
+"claude-haiku-4.5": {
+  "reasoning": true,
+  "variants": {
+    "high": {
+      "options": {
+        "thinking": {
+          "budgetTokens": 32000,
+          "type": "enabled"
+        }
+      }
+    }
+  }
+}
+```
+
+### How OpenCode v1.1.46 Actually Handles Copilot Reasoning
+
+OpenCode created a custom Copilot SDK (`packages/opencode/src/provider/sdk/copilot/`) that:
+
+1. **Does NOT use Anthropic's `/v1/messages` endpoint** - uses standard `/chat/completions`
+2. **Sends `thinking_budget` parameter** in request args
+3. **Looks for `reasoning_text` and `reasoning_opaque` fields** in response
+4. **Preserves `reasoning_opaque`** for multi-turn conversations
+
+### Key Response Schema Fields (Copilot-specific)
+```typescript
+message: {
+  content: z.string().nullish(),
+  reasoning_text: z.string().nullish(),      // Reasoning content
+  reasoning_opaque: z.string().nullish(),    // Opaque token for multi-turn
+}
+```
+
+### Provider Options Mapping
+The custom SDK accepts:
+- `thinking_budget` → budget tokens for thinking
+- `reasoningEffort` → low/medium/high effort level
+
+### Why Standard SDK Doesn't Work
+- `@ai-sdk/github-copilot` doesn't look for `reasoning_text` field
+- It doesn't pass `thinking_budget` to the API
+- It doesn't preserve `reasoning_opaque` for conversation continuity
+
+### Solution Required
+To enable Copilot reasoning, need to either:
+1. Wait for `@ai-sdk/github-copilot` to add support
+2. Copy OpenCode's custom `sdk/copilot` implementation
+3. Contribute the feature upstream

package/dist/template/.opencode/memory/observations/2026-01-31-learning-opencode-custom-tools-api.md

@@ -0,0 +1,48 @@
+---
+type: learning
+created: 2026-01-31T13:08:45.478Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["opencode", "custom-tools", "plugin", "bun-shell", "tool-schema"]
+---
+
+# 📚 OpenCode Custom Tools API
+
+🟢 **Confidence:** high
+
+## Proper Custom Tool Format
+
+OpenCode custom tools must use the `@opencode-ai/plugin` package:
+
+```typescript
+import { tool } from "@opencode-ai/plugin";
+
+export default tool({
+  description: "Tool description",
+  args: {
+    param: tool.schema.string().describe("Parameter description"),
+  },
+  async execute(args, context) {
+    // context provides: agent, sessionID, messageID, directory, worktree
+    return "result";
+  },
+});
+```
+
+### Key Points:
+1. **Import**: `import { tool } from "@opencode-ai/plugin"`
+2. **Schema**: Use `tool.schema` (which is Zod) for argument types
+3. **Shell commands**: Use `Bun.$` for shell commands, NOT Node.js child_process
+4. **Context**: Second argument provides session info (directory, worktree, etc.)
+5. **Multiple exports**: Each named export becomes `<filename>_<exportname>` tool
+
+### Shell Command Example:
+```typescript
+// Use Bun shell (NOT child_process)
+const result = await Bun.$`tmux -V`.quiet();
+return result.stdout.toString().trim();
+```
+
+### Docs Reference:
+https://opencode.ai/docs/custom-tools/

package/dist/template/.opencode/memory/observations/2026-01-31-learning-opencode-v1-1-48-skills-as-slash-command.md

@@ -0,0 +1,21 @@
+---
+type: learning
+created: 2026-01-31T18:45:52.872Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["opencode", "skills", "slash-commands", "v1.1.48", "TUI", "implement"]
+---
+
+# 📚 OpenCode v1.1.48: Skills as slash commands
+
+🟢 **Confidence:** high
+
+OpenCode v1.1.48 introduced the ability to invoke skills as slash commands in the TUI.
+
+This means:
+1. Skills in `.opencode/skill/` can be invoked directly via `/skill-name`
+2. Commands in `.opencode/command/` that load skills via `skill({ name: "..." })` need to stay consistent with actual skill capabilities
+3. When simplifying tools/skills, must also update any commands that reference them
+
+Example: `/implement` loads swarm-coordination skill and uses swarm-monitor operations - if those operations change, implement.md must be updated too.

package/dist/template/.opencode/memory/observations/2026-01-31-learning-swarm-system-simplified-removed-mailbox-.md

@@ -0,0 +1,30 @@
+---
+type: learning
+created: 2026-01-31T19:06:48.076Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["swarm", "beads", "parallel execution", "task tool", "mailbox removal"]
+files: [".opencode/tool/swarm-monitor.ts", ".opencode/command/implement.md", ".opencode/command/handoff.md", ".opencode/command/resume.md", ".opencode/command/new-feature.md", ".opencode/command/research.md", ".opencode/skill/beads/SKILL.md", ".opencode/skill/beads-bridge/SKILL.md", ".opencode/skill/swarm-coordination/SKILL.md"]
+---
+
+# 📚 Swarm system simplified - removed mailbox operations
+
+🟢 **Confidence:** high
+
+The swarm system has been simplified to use Task tool for parallel execution instead of internal mailbox operations. Removed obsolete operations: restore_todos, persist_todos, mail_send, mail_read, get_todos. 
+
+Current valid swarm-monitor operations: progress_update, render_block, status, clear
+
+Updated files:
+- .opencode/tool/swarm-monitor.ts (removed obsolete operations)
+- .opencode/command/implement.md (updated examples)
+- .opencode/command/handoff.md (removed persist_todos)
+- .opencode/command/resume.md (removed restore_todos)
+- .opencode/command/new-feature.md (removed mail_send)
+- .opencode/command/research.md (simplified examples)
+- .opencode/skill/beads/SKILL.md (added beads-bridge section)
+- .opencode/skill/beads-bridge/SKILL.md (removed obsolete operations)
+- .opencode/skill/swarm-coordination/SKILL.md (removed obsolete operations)
+
+Key insight: Task tool results replace mailbox messages. Workers return completion status directly via Task results, not via mail_send/mail_read.

package/dist/template/.opencode/memory/observations/2026-01-31-learning-v1-1-48-native-copilot-reasoning-via-pr-.md

@@ -0,0 +1,45 @@
+---
+type: learning
+created: 2026-01-31T17:23:15.170Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["v1.1.48", "copilot", "reasoning", "native", "PR 8900", "thinking_budget", "reasoning_opaque", "reasoning_text"]
+---
+
+# 📚 v1.1.48 Native Copilot Reasoning via PR 8900
+
+🟢 **Confidence:** high
+
+## v1.1.48 Native Copilot Reasoning Support (PR #8900)
+
+OpenCode v1.1.48 includes native Copilot-specific provider that properly handles reasoning tokens! This was merged Jan 31, 2026.
+
+### What PR #8900 Does:
+1. Creates dedicated Copilot provider under `src/provider/sdk/copilot/`
+2. Handles `reasoning_text` and `reasoning_opaque` fields natively
+3. Properly stores and passes `reasoning_opaque` back to Copilot API for multi-turn context
+4. Uses `providerOptions.copilot` key (not `openaiCompatible`)
+5. Adds `copilot_cache_control` to all messages
+
+### Key Implementation Details:
+- Provider options key changed from `openaiCompatible` to `copilot`
+- Assistant messages include `reasoning_text` and `reasoning_opaque`
+- The opaque signature MUST be passed back for multi-turn reasoning to work properly
+- Gemini models work with reasoning; Claude thinking is NOT yet supported server-side by GitHub
+
+### For Plugin Configuration (v1.1.48+):
+- NO custom SDK needed anymore
+- Use native `github-copilot` provider
+- Enable reasoning with `reasoning: true` in model config
+- May need to pass `thinking_budget` via providerOptions.copilot
+
+### GitHub Copilot Model Capabilities (from API):
+- Claude models support `max_thinking_budget: 32000` and `min_thinking_budget: 1024`
+- GPT models use `/responses` API endpoint
+- Claude uses chat completions API
+
+### Important Note:
+- Gemini models DO return `reasoning_text` via Copilot
+- Claude extended thinking is blocked SERVER-SIDE by GitHub (not a client issue)
+- The custom SDK we built is now obsolete for v1.1.48+

package/dist/template/.opencode/memory/observations/2026-01-31-warning-cannot-add-custom-config-to-opencode-jso.md

@@ -0,0 +1,18 @@
+---
+type: warning
+created: 2026-01-31T13:04:00.635Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["opencode.json", "config", "schema", "tmux", "custom-config", "validation"]
+---
+
+# ⚠️ Cannot add custom config to opencode.json
+
+🟢 **Confidence:** high
+
+opencode.json has a strict JSON schema (https://opencode.ai/config.json). You CANNOT add arbitrary config sections like "tmux". The schema only allows specific keys like: agent, autoupdate, compaction, experimental, formatter, instructions, keybinds, mcp, model, permission, plugin, provider, share, small_model, tools, tui, watcher.
+
+Custom tool configuration must be handled within the tool itself (via environment variables, separate config file, or hardcoded defaults) - NOT in opencode.json.
+
+The user already commented out the invalid tmux section at lines 785-790.

package/dist/template/.opencode/memory/observations/2026-01-31-warning-copilot-claude-v1-endpoint-returns-404-c.md

@@ -0,0 +1,48 @@
+---
+type: warning
+created: 2026-01-31T05:19:40.401Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["copilot", "claude", "routing", "v1", "404", "not-found", "anthropic", "messages-api", "limitation"]
+files: ["api.githubcopilot.com"]
+---
+
+# ⚠️ Copilot Claude /v1 Endpoint Returns 404 - Confirmed
+
+🟢 **Confidence:** high
+
+## Confirmed: GitHub Copilot Does NOT Support Claude /v1 Endpoint
+
+### Test Result
+Re-enabling Claude routing with `/v1` endpoint causes 404 "Not Found" errors.
+
+### Root Cause
+GitHub Copilot API (`api.githubcopilot.com`) only exposes:
+- `/v1/chat/completions` - OpenAI-compatible endpoint
+
+It does NOT expose:
+- `/v1/messages` - Anthropic's native Messages API (required for extended thinking)
+
+### Conclusion
+**Extended thinking/reasoning is NOT available for Claude through GitHub Copilot.**
+
+The Copilot API acts as a proxy that:
+1. Accepts OpenAI-format requests
+2. Translates them internally to Claude
+3. Returns OpenAI-format responses
+
+This translation layer strips thinking blocks and doesn't support the `thinking` parameter.
+
+### Final Configuration
+All Claude models must use `@ai-sdk/github-copilot` SDK, NOT `@ai-sdk/anthropic`.
+
+```typescript
+// This is the ONLY working configuration
+model.api.npm = "@ai-sdk/github-copilot";
+```
+
+### Workaround for Reasoning
+To get Claude reasoning, users must:
+1. Use direct Anthropic API with separate API key
+2. Or use a provider that exposes native Anthropic Messages API (Vertex AI, AWS Bedrock)

package/dist/template/.opencode/memory/observations/2026-01-31-warning-opencode-v1-1-48-claude-thinking-block-s.md

@@ -0,0 +1,51 @@
+---
+type: warning
+created: 2026-01-31T17:14:16.151Z
+confidence: high
+valid_until: null
+superseded_by: null
+concepts: ["opencode", "copilot", "claude", "thinking-block", "signature", "reasoning", "v1.1.48", "bug", "sdk", "backup"]
+---
+
+# ⚠️ OpenCode v1.1.48+ Claude Thinking Block Signature Bug
+
+🟢 **Confidence:** high
+
+## Problem
+When upgrading OpenCode from v1.1.48 to dev branch, Claude models via GitHub Copilot fail with:
+`messages.1.content.0: Invalid 'signature' in 'thinking' block`
+
+## Root Cause
+- OpenCode v1.1.48+ native `@ai-sdk/github-copilot` SDK validates thinking block signatures
+- Switching models mid-session causes signature validation failures
+- Thinking blocks from one model (GLM 4.7, MiniMax, etc.) have incompatible signatures with Claude
+- GitHub issue #6418, fix in draft PR #8958
+
+## Working Configuration (Pre-upgrade)
+Location: `backup/sdk/` contains custom copilot SDK that bypassed signature validation
+- `backup/sdk/copilot/` - Custom @ai-sdk/github-copilot implementation
+- `~/.config/opencode/plugin/copilot-auth.ts` - Auth plugin with disabled custom reasoning (664 lines)
+- `~/.config/opencode/opencode.json` - Model configurations
+
+## Key Files in Backup SDK
+```
+backup/sdk/copilot/
+├── chat/
+│   ├── convert-to-openai-compatible-chat-messages.ts
+│   ├── get-response-metadata.ts
+│   ├── map-openai-compatible-finish-reason.ts
+│   ├── openai-compatible-api-types.ts
+│   ├── openai-compatible-chat-language-model.ts
+│   ├── openai-compatible-chat-options.ts
+│   ├── openai-compatible-metadata-extractor.ts
+│   └── openai-compatible-prepare-tools.ts
+├── copilot-provider.ts
+├── index.ts
+└── openai-compatible-error.ts
+```
+
+## Workarounds
+1. Don't switch to Claude mid-session from models with thinking blocks
+2. Start fresh sessions when using Claude with extended thinking
+3. Wait for PR #8958 to be merged
+4. Restore custom SDK from backup (breaks native reasoning handling)