opencodekit 0.20.8 → 0.21.1

package/dist/template/.opencode/opencodex-fast.jsonc

@@ -1,3 +1,3 @@
 {
-  "enabled": true
+  "enabled": false
 }

package/dist/template/.opencode/package.json

@@ -12,11 +12,11 @@
   },
   "dependencies": {
     "@google/stitch-sdk": "^0.0.3",
-    "@opencode-ai/plugin": "1.4.3"
+    "@opencode-ai/plugin": "1.4.9"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",
     "bun-types": "^1.3.9",
     "typescript": "^5.9.3"
   }
-}
+}

package/dist/template/.opencode/plugin/copilot-auth.ts

@@ -11,6 +11,8 @@
  * these fields to AI SDK's reasoning content parts.
  */
 
+import path from "node:path";
+import { pathToFileURL } from "node:url";
 import type { Plugin } from "@opencode-ai/plugin";
 
 const CLIENT_ID = "Ov23li8tweQw6odWQebz";
@@ -43,10 +45,7 @@ function setLogger(client: any) {
 const OAUTH_POLLING_SAFETY_MARGIN_MS = 3000; // 3 seconds
 
 const HEADERS = {
-	"User-Agent": "GitHubCopilotChat/0.35.0",
-	"Editor-Version": "vscode/1.107.0",
-	"Editor-Plugin-Version": "copilot-chat/0.35.0",
-	"Copilot-Integration-Id": "vscode-chat",
+	"User-Agent": "opencode/1.3.17",
 };
 
 const RESPONSES_API_ALTERNATE_INPUT_TYPES = [
@@ -544,10 +543,14 @@ function sanitizeResponseInputIds(input: any[]): any[] {
 	});
 }
 
-export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
+export const CopilotAuthPlugin: Plugin = async ({ client: sdk, directory }) => {
 	// Initialize logger with the SDK client
 	setLogger(sdk);
 
+	const localCopilotSdk = pathToFileURL(
+		path.join(directory, ".opencode", "plugin", "sdk", "copilot", "index.ts"),
+	).toString();
+
 	return {
 		auth: {
 			provider: "github-copilot",
@@ -572,11 +575,10 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 							},
 						};
 
-						// All models use the standard github-copilot SDK
-						// Reasoning support for Claude models is handled via:
-						// 1. The fetch wrapper adds thinking_budget to request body
-						// 2. The fetch wrapper strips invalid thinking blocks from messages
-						model.api.npm = "@ai-sdk/github-copilot";
+						// Route all Copilot models through the local file-based SDK.
+						// OpenCode's built-in github-copilot model loader will automatically
+						// choose sdk.responses(model) for GPT-5+ and sdk.chat(model) otherwise.
+						model.api.npm = localCopilotSdk;
 					}
 				}
 
@@ -862,6 +864,65 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 										),
 								);
 							}
+
+							// Sanitize tool definitions: strip non-standard fields like
+							// "custom" (wrapping eager_input_streaming) injected by
+							// runtime layers. These cause "Extra inputs are not permitted"
+							// on the Copilot API.
+							const toolSource = modifiedBody || body;
+							if (Array.isArray(toolSource?.tools)) {
+								let toolsChanged = false;
+								const sanitizedTools = toolSource.tools.map(
+									(tool: any) => {
+										if (!tool || typeof tool !== "object") return tool;
+
+										let result = tool;
+
+										// Strip top-level non-standard fields from tool object
+										if (
+											"custom" in result ||
+											"eager_input_streaming" in result
+										) {
+											toolsChanged = true;
+											const {
+												custom: _custom,
+												eager_input_streaming: _eis,
+												...clean
+											} = result;
+											result = clean;
+										}
+
+										// Also check nested function object (Chat Completions format)
+										if (
+											result.function &&
+											typeof result.function === "object" &&
+											("custom" in result.function ||
+												"eager_input_streaming" in result.function)
+										) {
+											toolsChanged = true;
+											const {
+												custom: _c,
+												eager_input_streaming: _e,
+												...cleanFn
+											} = result.function;
+											result = { ...result, function: cleanFn };
+										}
+
+										return result;
+									},
+								);
+
+								if (toolsChanged) {
+									modifiedBody = {
+										...(modifiedBody || body),
+										tools: sanitizedTools,
+									};
+									log(
+										"debug",
+										"Stripped non-standard fields (custom/eager_input_streaming) from tool definitions",
+									);
+								}
+							}
 						} catch {}
 
 						const headers: Record<string, string> = {
@@ -1053,7 +1114,7 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 							headers: {
 								Accept: "application/json",
 								"Content-Type": "application/json",
-								"User-Agent": "GitHubCopilotChat/0.35.0",
+								"User-Agent": "opencode/1.3.17",
 							},
 							body: JSON.stringify({
 								client_id: CLIENT_ID,
@@ -1078,7 +1139,7 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 										headers: {
 											Accept: "application/json",
 											"Content-Type": "application/json",
-											"User-Agent": "GitHubCopilotChat/0.35.0",
+											"User-Agent": "opencode/1.3.17",
 										},
 										body: JSON.stringify({
 											client_id: CLIENT_ID,
@@ -1162,6 +1223,10 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 				output.headers["anthropic-beta"] = "interleaved-thinking-2025-05-14";
 			}
 
+			// When using the local Copilot SDK, let the SDK/message pipeline decide
+			// initiator semantics. Overriding x-initiator here can break Responses routing.
+			if (input.model?.api?.npm === localCopilotSdk) return;
+
 			// Mark subagent sessions as agent-initiated (matching standard Copilot tools)
 			try {
 				const session = await sdk.session
@@ -1179,5 +1244,14 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 				// Ignore errors from session lookup
 			}
 		},
+		// Hook to strip maxOutputTokens for GPT models (matches upstream Copilot CLI behavior)
+		"chat.params": async (input: any, output: any) => {
+			if (!input.model?.providerID?.includes("github-copilot")) return;
+
+			// GPT models don't support maxOutputTokens through the Copilot proxy
+			if (input.model?.api?.id?.includes("gpt")) {
+				output.maxOutputTokens = undefined;
+			}
+		},
 	};
 };

package/dist/template/.opencode/plugin/prompt-leverage.ts

@@ -0,0 +1,191 @@
+/**
+ * Prompt Leverage Plugin
+ *
+ * Automatically upgrades every user prompt with the seven-block framework before the AI processes it.
+ * Uses chat.message hook — safely inspects input structure before accessing properties.
+ */
+
+import type { Plugin } from "@opencode-ai/plugin";
+
+const TASK_KEYWORDS: Record<string, string[]> = {
+  coding: [
+    "code",
+    "bug",
+    "repo",
+    "refactor",
+    "test",
+    "implement",
+    "fix",
+    "function",
+    "api",
+    "add",
+    "update",
+    "remove",
+  ],
+  research: [
+    "research",
+    "compare",
+    "find",
+    "latest",
+    "sources",
+    "analyze",
+    "look up",
+  ],
+  writing: [
+    "write",
+    "rewrite",
+    "draft",
+    "email",
+    "memo",
+    "blog",
+    "copy",
+    "tone",
+  ],
+  review: ["review", "audit", "critique", "inspect", "evaluate", "assess"],
+  planning: ["plan", "roadmap", "strategy", "framework", "outline"],
+  analysis: ["analyze", "explain", "break down", "diagnose", "root cause"],
+};
+
+function detectTask(prompt: string): string {
+  const lowered = prompt.toLowerCase();
+  const scores: Record<string, number> = {};
+  for (const [task, keywords] of Object.entries(TASK_KEYWORDS)) {
+    scores[task] = keywords.filter((k) => lowered.includes(k)).length;
+  }
+  const best = Object.entries(scores).sort((a, b) => b[1] - a[1]);
+  return best[0]?.[1] ? best[0][0] : "analysis";
+}
+
+function inferIntensity(prompt: string, task: string): string {
+  const lowered = prompt.toLowerCase();
+  if (
+    ["careful", "deep", "thorough", "critical", "production"].some((t) =>
+      lowered.includes(t),
+    )
+  ) {
+    return "Deep";
+  }
+  if (task === "coding" || task === "research" || task === "review") {
+    return "Standard";
+  }
+  return "Light";
+}
+
+function buildToolRules(task: string): string {
+  const rules: Record<string, string> = {
+    coding:
+      "Inspect the relevant files and dependencies first. Validate the final change with the narrowest useful checks before broadening scope.",
+    research:
+      "Retrieve evidence from reliable sources before concluding. Do not guess facts that can be checked.",
+    review:
+      "Read enough surrounding context to understand intent before critiquing. Distinguish confirmed issues from plausible risks.",
+  };
+  return (
+    rules[task] ||
+    "Use tools or extra context only when they materially improve correctness or completeness."
+  );
+}
+
+function buildOutputContract(task: string): string {
+  const contracts: Record<string, string> = {
+    coding:
+      "Return the result in a practical execution format: concise summary, concrete changes or code, validation notes, and any remaining risks.",
+    research:
+      "Return a structured synthesis with key findings, supporting evidence, uncertainty where relevant, and a concise bottom line.",
+    writing:
+      "Return polished final copy in the requested tone and format. If useful, include a short rationale for major editorial choices.",
+    review:
+      "Return findings grouped by severity or importance, explain why each matters, and suggest the smallest credible next step.",
+  };
+  return (
+    contracts[task] ||
+    "Return a clear, well-structured response matched to the task, with no unnecessary verbosity."
+  );
+}
+
+function upgradePrompt(userPrompt: string): string {
+  const normalized = userPrompt.trim().replace(/\s+/g, " ");
+  const task = detectTask(normalized);
+  const intensity = inferIntensity(normalized, task);
+  const toolRules = buildToolRules(task);
+  const outputContract = buildOutputContract(task);
+
+  if (normalized.includes("Objective:") && normalized.includes("Context:")) {
+    return userPrompt;
+  }
+  if (normalized.length < 15 || normalized.split(" ").length < 3) {
+    return userPrompt;
+  }
+
+  return `Objective:
+- Complete this task: ${normalized}
+- Optimize for a correct, useful result rather than a merely plausible one.
+
+Context:
+- Preserve the user's original intent and constraints.
+- Surface any key assumptions if required information is missing.
+
+Work Style:
+- Task type: ${task}
+- Effort level: ${intensity}
+- Understand the problem broadly enough to avoid narrow mistakes, then go deep where the risk or complexity is highest.
+- Use first-principles reasoning before proposing changes.
+- For non-trivial work, review the result once with fresh eyes before finalizing.
+
+Tool Rules:
+- ${toolRules}
+
+Output Contract:
+- ${outputContract}
+
+Verification:
+- Check correctness, completeness, and edge cases.
+- Improve obvious weaknesses if a better approach is available within scope.
+
+Done Criteria:
+- Stop only when the response satisfies the task, matches the requested format, and passes the verification step.`;
+}
+
+export const PromptLeverage: Plugin = async ({ client }) => {
+  const showToast = async (message: string) => {
+    try {
+      await client.tui.showToast({
+        body: {
+          title: "PromptLeverage",
+          message,
+          variant: "info",
+          duration: 3000,
+        },
+      });
+    } catch {
+      /* Toast API unavailable */
+    }
+  };
+
+  return {
+    "experimental.chat.messages.transform": async (input: any, output: any) => {
+      try {
+        const msgs = output.messages || input.messages || [];
+
+        // Find the last message with parts (user message)
+        for (let i = msgs.length - 1; i >= 0; i--) {
+          const msg = msgs[i];
+          if (msg?.parts) {
+            for (const part of msg.parts) {
+              if (part.type === "text" && part.text) {
+                const upgraded = upgradePrompt(part.text);
+                if (upgraded !== part.text) {
+                  part.text = upgraded;
+                  showToast("Upgraded prompt!");
+                }
+              }
+            }
+            break; // Only upgrade the most recent message
+          }
+        }
+      } catch (e: any) {
+        showToast(`Error: ${e.message}`);
+      }
+    },
+  };
+};

package/dist/template/.opencode/plugin/sdk/copilot/copilot-provider.ts

@@ -1,10 +1,11 @@
 import type { LanguageModelV2 } from "@ai-sdk/provider";
 import {
 	type FetchFunction,
-	withUserAgentSuffix,
 	withoutTrailingSlash,
+	withUserAgentSuffix,
 } from "@ai-sdk/provider-utils";
-import { OpenAICompatibleChatLanguageModel } from "./chat/openai-compatible-chat-language-model";
+import { OpenAICompatibleChatLanguageModel } from "./chat/openai-compatible-chat-language-model.js";
+import { OpenAIResponsesLanguageModel } from "./responses/openai-responses-language-model.js";
 
 // Import the version or define it
 const VERSION = "0.1.0";
@@ -41,6 +42,7 @@ export interface OpenaiCompatibleProviderSettings {
 export interface OpenaiCompatibleProvider {
 	(modelId: OpenaiCompatibleModelId): LanguageModelV2;
 	chat(modelId: OpenaiCompatibleModelId): LanguageModelV2;
+	responses(modelId: OpenaiCompatibleModelId): LanguageModelV2;
 	languageModel(modelId: OpenaiCompatibleModelId): LanguageModelV2;
 }
 
@@ -78,6 +80,15 @@ export function createOpenaiCompatible(
 		});
 	};
 
+	const createResponsesModel = (modelId: OpenaiCompatibleModelId) => {
+		return new OpenAIResponsesLanguageModel(modelId, {
+			provider: `${options.name ?? "openai-compatible"}.responses`,
+			headers: getHeaders,
+			url: ({ path, modelId: _modelId }) => `${baseURL}${path}`,
+			fetch: options.fetch,
+		});
+	};
+
 	const createLanguageModel = (modelId: OpenaiCompatibleModelId) =>
 		createChatModel(modelId);
 
@@ -86,6 +97,7 @@ export function createOpenaiCompatible(
 
 	provider.languageModel = createLanguageModel;
 	provider.chat = createChatModel;
+	provider.responses = createResponsesModel;
 
 	return provider as OpenaiCompatibleProvider;
 }

package/dist/template/.opencode/plugin/sdk/copilot/index.ts

@@ -1,5 +1,5 @@
-export { createOpenaiCompatible, openaiCompatible } from "./copilot-provider";
+export { createOpenaiCompatible, openaiCompatible } from "./copilot-provider.js";
 export type {
 	OpenaiCompatibleProvider,
 	OpenaiCompatibleProviderSettings,
-} from "./copilot-provider";
+} from "./copilot-provider.js";