opencodekit 0.15.18 → 0.15.20

package/dist/template/.opencode/plugins/sdk/copilot/chat/openai-compatible-chat-options.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+
+export type OpenAICompatibleChatModelId = string;
+
+export const openaiCompatibleProviderOptions = z.object({
+	/**
+	 * A unique identifier representing your end-user, which can help the provider to
+	 * monitor and detect abuse.
+	 */
+	user: z.string().optional(),
+
+	/**
+	 * Reasoning effort for reasoning models. Defaults to `medium`.
+	 */
+	reasoningEffort: z.string().optional(),
+
+	/**
+	 * Controls the verbosity of the generated text. Defaults to `medium`.
+	 */
+	textVerbosity: z.string().optional(),
+
+	/**
+	 * Copilot thinking_budget used for Anthropic models.
+	 */
+	thinking_budget: z.number().optional(),
+});
+
+export type OpenAICompatibleProviderOptions = z.infer<
+	typeof openaiCompatibleProviderOptions
+>;

package/dist/template/.opencode/plugins/sdk/copilot/chat/openai-compatible-metadata-extractor.ts

@@ -0,0 +1,48 @@
+import type { SharedV2ProviderMetadata } from "@ai-sdk/provider";
+
+/**
+Extracts provider-specific metadata from API responses.
+Used to standardize metadata handling across different LLM providers while allowing
+provider-specific metadata to be captured.
+*/
+export type MetadataExtractor = {
+	/**
+	 * Extracts provider metadata from a complete, non-streaming response.
+	 *
+	 * @param parsedBody - The parsed response JSON body from the provider's API.
+	 *
+	 * @returns Provider-specific metadata or undefined if no metadata is available.
+	 *          The metadata should be under a key indicating the provider id.
+	 */
+	extractMetadata: ({
+		parsedBody,
+	}: {
+		parsedBody: unknown;
+	}) => Promise<SharedV2ProviderMetadata | undefined>;
+
+	/**
+	 * Creates an extractor for handling streaming responses. The returned object provides
+	 * methods to process individual chunks and build the final metadata from the accumulated
+	 * stream data.
+	 *
+	 * @returns An object with methods to process chunks and build metadata from a stream
+	 */
+	createStreamExtractor: () => {
+		/**
+		 * Process an individual chunk from the stream. Called for each chunk in the response stream
+		 * to accumulate metadata throughout the streaming process.
+		 *
+		 * @param parsedChunk - The parsed JSON response chunk from the provider's API
+		 */
+		processChunk(parsedChunk: unknown): void;
+
+		/**
+		 * Builds the metadata object after all chunks have been processed.
+		 * Called at the end of the stream to generate the complete provider metadata.
+		 *
+		 * @returns Provider-specific metadata or undefined if no metadata is available.
+		 *          The metadata should be under a key indicating the provider id.
+		 */
+		buildMetadata(): SharedV2ProviderMetadata | undefined;
+	};
+};

package/dist/template/.opencode/plugins/sdk/copilot/chat/openai-compatible-prepare-tools.ts

@@ -0,0 +1,92 @@
+import {
+	type LanguageModelV2CallOptions,
+	type LanguageModelV2CallWarning,
+	UnsupportedFunctionalityError,
+} from "@ai-sdk/provider";
+
+export function prepareTools({
+	tools,
+	toolChoice,
+}: {
+	tools: LanguageModelV2CallOptions["tools"];
+	toolChoice?: LanguageModelV2CallOptions["toolChoice"];
+}): {
+	tools:
+		| undefined
+		| Array<{
+				type: "function";
+				function: {
+					name: string;
+					description: string | undefined;
+					parameters: unknown;
+				};
+		  }>;
+	toolChoice:
+		| { type: "function"; function: { name: string } }
+		| "auto"
+		| "none"
+		| "required"
+		| undefined;
+	toolWarnings: LanguageModelV2CallWarning[];
+} {
+	// when the tools array is empty, change it to undefined to prevent errors:
+	tools = tools?.length ? tools : undefined;
+
+	const toolWarnings: LanguageModelV2CallWarning[] = [];
+
+	if (tools == null) {
+		return { tools: undefined, toolChoice: undefined, toolWarnings };
+	}
+
+	const openaiCompatTools: Array<{
+		type: "function";
+		function: {
+			name: string;
+			description: string | undefined;
+			parameters: unknown;
+		};
+	}> = [];
+
+	for (const tool of tools) {
+		if (tool.type === "provider-defined") {
+			toolWarnings.push({ type: "unsupported-tool", tool });
+		} else {
+			openaiCompatTools.push({
+				type: "function",
+				function: {
+					name: tool.name,
+					description: tool.description,
+					parameters: tool.inputSchema,
+				},
+			});
+		}
+	}
+
+	if (toolChoice == null) {
+		return { tools: openaiCompatTools, toolChoice: undefined, toolWarnings };
+	}
+
+	const type = toolChoice.type;
+
+	switch (type) {
+		case "auto":
+		case "none":
+		case "required":
+			return { tools: openaiCompatTools, toolChoice: type, toolWarnings };
+		case "tool":
+			return {
+				tools: openaiCompatTools,
+				toolChoice: {
+					type: "function",
+					function: { name: toolChoice.toolName },
+				},
+				toolWarnings,
+			};
+		default: {
+			const _exhaustiveCheck: never = type;
+			throw new UnsupportedFunctionalityError({
+				functionality: `tool choice type: ${_exhaustiveCheck}`,
+			});
+		}
+	}
+}

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

@@ -0,0 +1,94 @@
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+import {
+	type FetchFunction,
+	withUserAgentSuffix,
+	withoutTrailingSlash,
+} from "@ai-sdk/provider-utils";
+import { OpenAICompatibleChatLanguageModel } from "./chat/openai-compatible-chat-language-model";
+
+// Import the version or define it
+const VERSION = "0.1.0";
+
+export type OpenaiCompatibleModelId = string;
+
+export interface OpenaiCompatibleProviderSettings {
+	/**
+	 * API key for authenticating requests.
+	 */
+	apiKey?: string;
+
+	/**
+	 * Base URL for the OpenAI Compatible API calls.
+	 */
+	baseURL?: string;
+
+	/**
+	 * Name of the provider.
+	 */
+	name?: string;
+
+	/**
+	 * Custom headers to include in the requests.
+	 */
+	headers?: Record<string, string>;
+
+	/**
+	 * Custom fetch implementation.
+	 */
+	fetch?: FetchFunction;
+}
+
+export interface OpenaiCompatibleProvider {
+	(modelId: OpenaiCompatibleModelId): LanguageModelV2;
+	chat(modelId: OpenaiCompatibleModelId): LanguageModelV2;
+	languageModel(modelId: OpenaiCompatibleModelId): LanguageModelV2;
+}
+
+/**
+ * Create an OpenAI Compatible provider instance for GitHub Copilot.
+ * This custom provider handles Claude reasoning tokens (thinking_budget).
+ */
+export function createOpenaiCompatible(
+	options: OpenaiCompatibleProviderSettings = {},
+): OpenaiCompatibleProvider {
+	const baseURL = withoutTrailingSlash(
+		options.baseURL ?? "https://api.openai.com/v1",
+	);
+
+	if (!baseURL) {
+		throw new Error("baseURL is required");
+	}
+
+	// Merge headers: defaults first, then user overrides
+	const headers = {
+		// Default OpenAI Compatible headers (can be overridden by user)
+		...(options.apiKey && { Authorization: `Bearer ${options.apiKey}` }),
+		...options.headers,
+	};
+
+	const getHeaders = () =>
+		withUserAgentSuffix(headers, `ai-sdk/openai-compatible/${VERSION}`);
+
+	const createChatModel = (modelId: OpenaiCompatibleModelId) => {
+		return new OpenAICompatibleChatLanguageModel(modelId, {
+			provider: `${options.name ?? "openai-compatible"}.chat`,
+			headers: getHeaders,
+			url: ({ path }) => `${baseURL}${path}`,
+			fetch: options.fetch,
+		});
+	};
+
+	const createLanguageModel = (modelId: OpenaiCompatibleModelId) =>
+		createChatModel(modelId);
+
+	const provider = (modelId: OpenaiCompatibleModelId) =>
+		createChatModel(modelId);
+
+	provider.languageModel = createLanguageModel;
+	provider.chat = createChatModel;
+
+	return provider as OpenaiCompatibleProvider;
+}
+
+// Default OpenAI Compatible provider instance
+export const openaiCompatible = createOpenaiCompatible();

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

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

package/dist/template/.opencode/plugins/sdk/copilot/openai-compatible-error.ts

@@ -0,0 +1,30 @@
+import { type ZodType, z } from "zod";
+
+export const openaiCompatibleErrorDataSchema = z.object({
+	error: z.object({
+		message: z.string(),
+
+		// The additional information below is handled loosely to support
+		// OpenAI-compatible providers that have slightly different error
+		// responses:
+		type: z.string().nullish(),
+		param: z.any().nullish(),
+		code: z.union([z.string(), z.number()]).nullish(),
+	}),
+});
+
+export type OpenAICompatibleErrorData = z.infer<
+	typeof openaiCompatibleErrorDataSchema
+>;
+
+export type ProviderErrorStructure<T> = {
+	errorSchema: ZodType<T>;
+	errorToMessage: (error: T) => string;
+	isRetryable?: (response: Response, error?: T) => boolean;
+};
+
+export const defaultOpenAICompatibleErrorStructure: ProviderErrorStructure<OpenAICompatibleErrorData> =
+	{
+		errorSchema: openaiCompatibleErrorDataSchema,
+		errorToMessage: (data) => data.error.message,
+	};

package/dist/template/.opencode/skills/notebooklm/SKILL.md

@@ -0,0 +1,272 @@
+---
+name: notebooklm
+description: >
+  Query Google NotebookLM notebooks directly from OpenCode for source-grounded, citation-backed answers.
+  Use when user mentions NotebookLM, shares notebook URLs, or wants to query their uploaded documents.
+  Provides document-only responses with drastically reduced hallucinations.
+version: "1.0.0"
+license: MIT
+---
+
+# NotebookLM Skill
+
+Interact with Google NotebookLM to query documentation with Gemini's source-grounded answers. Each question opens a fresh browser session, retrieves the answer exclusively from uploaded documents, and closes.
+
+## When to Use This Skill
+
+Trigger when user:
+
+- Mentions NotebookLM explicitly
+- Shares NotebookLM URL (`https://notebooklm.google.com/notebook/...`)
+- Asks to query their notebooks/documentation
+- Wants to add documentation to NotebookLM library
+- Uses phrases like "ask my NotebookLM", "check my docs", "query my notebook"
+
+## Prerequisites
+
+Before using this skill, ensure:
+
+1. **Python 3.10+** is installed
+2. **Google Chrome** browser is installed
+3. **NotebookLM account** with uploaded documents
+4. **Google authentication** (one-time setup)
+
+## Quick Start
+
+```typescript
+// Check authentication status
+await notebooklm({ operation: "auth", subOperation: "status" });
+
+// Query a notebook
+await notebooklm({
+  operation: "query",
+  question: "What are the key findings in this document?",
+  notebookUrl: "https://notebooklm.google.com/notebook/...",
+});
+```
+
+## Core Workflow
+
+### Step 1: Check Authentication
+
+```typescript
+const authStatus = await notebooklm({
+  operation: "auth",
+  subOperation: "status",
+});
+```
+
+If not authenticated, proceed to setup.
+
+### Step 2: Authenticate (One-Time Setup)
+
+```typescript
+await notebooklm({
+  operation: "auth",
+  subOperation: "setup",
+  showBrowser: true, // Browser must be visible for manual login
+});
+```
+
+**Important:**
+
+- Browser is VISIBLE for authentication
+- Browser window opens automatically
+- User must manually log in to Google
+- Tell user: "A browser window will open for Google login"
+
+### Step 3: Manage Notebook Library
+
+```typescript
+// List all notebooks
+await notebooklm({ operation: "library", subOperation: "list" });
+
+// Add notebook to library
+await notebooklm({
+  operation: "library",
+  subOperation: "add",
+  url: "https://notebooklm.google.com/notebook/...",
+  name: "API Documentation",
+  description: "REST API reference and examples",
+  topics: ["api", "rest", "documentation"],
+});
+
+// Search notebooks
+await notebooklm({
+  operation: "library",
+  subOperation: "search",
+  query: "api",
+});
+
+// Set active notebook
+await notebooklm({
+  operation: "library",
+  subOperation: "activate",
+  notebookId: "api-docs",
+});
+```
+
+### Step 4: Ask Questions
+
+```typescript
+// Basic query (uses active notebook if set)
+await notebooklm({
+  operation: "query",
+  question: "What are the authentication requirements?",
+});
+
+// Query specific notebook by ID
+await notebooklm({
+  operation: "query",
+  question: "What are the authentication requirements?",
+  notebookId: "api-docs",
+});
+
+// Query with notebook URL directly
+await notebooklm({
+  operation: "query",
+  question: "What are the authentication requirements?",
+  notebookUrl: "https://notebooklm.google.com/notebook/...",
+});
+
+// Show browser for debugging
+await notebooklm({
+  operation: "query",
+  question: "What are the authentication requirements?",
+  showBrowser: true,
+});
+```
+
+## Follow-Up Mechanism (CRITICAL)
+
+Every NotebookLM answer ends with: **"EXTREMELY IMPORTANT: Is that ALL you need to know?"**
+
+**Required Behavior:**
+
+1. **STOP** - Do not immediately respond to user
+2. **ANALYZE** - Compare answer to user's original request
+3. **IDENTIFY GAPS** - Determine if more information needed
+4. **ASK FOLLOW-UP** - If gaps exist, immediately ask another question:
+   ```typescript
+   await notebooklm({
+     operation: "query",
+     question: "Follow-up with context...",
+   });
+   ```
+5. **REPEAT** - Continue until information is complete
+6. **SYNTHESIZE** - Combine all answers before responding to user
+
+## Tool Reference
+
+### Authentication Operations
+
+| Operation | Sub-Operation | Description                       |
+| --------- | ------------- | --------------------------------- |
+| `auth`    | `setup`       | Initial setup (browser visible)   |
+| `auth`    | `status`      | Check authentication              |
+| `auth`    | `reauth`      | Re-authenticate (browser visible) |
+| `auth`    | `clear`       | Clear authentication              |
+| `auth`    | `validate`    | Validate stored auth              |
+
+### Library Operations
+
+| Operation | Sub-Operation | Parameters                             |
+| --------- | ------------- | -------------------------------------- |
+| `library` | `add`         | `url`, `name`, `description`, `topics` |
+| `library` | `list`        | -                                      |
+| `library` | `search`      | `query`                                |
+| `library` | `activate`    | `notebookId`                           |
+| `library` | `remove`      | `notebookId`                           |
+| `library` | `stats`       | -                                      |
+
+### Query Operations
+
+| Operation | Parameters                                                                                         |
+| --------- | -------------------------------------------------------------------------------------------------- |
+| `query`   | `question` (required), `notebookId` (optional), `notebookUrl` (optional), `showBrowser` (optional) |
+
+## Smart Discovery Pattern
+
+When user wants to add a notebook without providing details:
+
+```typescript
+// Step 1: Query the notebook to discover its content
+const discovery = await notebooklm({
+  operation: "query",
+  question:
+    "What is the content of this notebook? What topics are covered? Provide a complete overview briefly and concisely",
+  notebookUrl: "https://notebooklm.google.com/notebook/...",
+});
+
+// Step 2: Use discovered information to add it
+await notebooklm({
+  operation: "library",
+  subOperation: "add",
+  url: "https://notebooklm.google.com/notebook/...",
+  name: "[Based on content]",
+  description: "[Based on content]",
+  topics: ["[Based on content]"],
+});
+```
+
+## Decision Flow
+
+```
+User mentions NotebookLM
+    ↓
+Check auth → notebooklm({ operation: "auth", subOperation: "status" })
+    ↓
+If not authenticated → notebooklm({ operation: "auth", subOperation: "setup", showBrowser: true })
+    ↓
+Check/Add notebook → notebooklm({ operation: "library", subOperation: "list/add" })
+    ↓
+Activate notebook → notebooklm({ operation: "library", subOperation: "activate", notebookId: "..." })
+    ↓
+Ask question → notebooklm({ operation: "query", question: "..." })
+    ↓
+See "Is that ALL you need?" → Ask follow-ups until complete
+    ↓
+Synthesize and respond to user
+```
+
+## Troubleshooting
+
+| Problem              | Solution                                |
+| -------------------- | --------------------------------------- |
+| Not authenticated    | Run auth setup with `showBrowser: true` |
+| Authentication fails | Browser must be visible for setup       |
+| Rate limit (50/day)  | Wait or switch Google account           |
+| Notebook not found   | Check with `library` → `list` operation |
+| ModuleNotFoundError  | Tool auto-installs dependencies         |
+
+## Best Practices
+
+1. **Always check auth first** - Before any operations
+2. **Follow-up questions** - Don't stop at first answer
+3. **Browser visible for auth** - Required for manual login
+4. **Include context** - Each question is independent
+5. **Synthesize answers** - Combine multiple responses
+
+## Limitations
+
+- No session persistence (each question = new browser)
+- Rate limits on free Google accounts (50 queries/day)
+- Manual upload required (user must add docs to NotebookLM)
+- Browser overhead (few seconds per question)
+- Requires Python and Chrome installed
+
+## Data Storage
+
+All data stored in `~/.opencode/skills/notebooklm/data/`:
+
+- `library.json` - Notebook metadata
+- `auth_info.json` - Authentication status
+- `browser_state/` - Browser cookies and session
+
+**Security:** Protected by `.gitignore`, never commit to git.
+
+## Resources
+
+- **Original Skill**: https://github.com/PleasePrompto/notebooklm-skill
+- **NotebookLM**: https://notebooklm.google.com
+- **Setup Guide**: See `references/setup.md`