@andershaf/testopencode 0.1.0

package/README.md

@@ -0,0 +1,54 @@
+# @andershaf/testopencode
+
+OpenCode custom provider for **CDF project AI** (`/api/v1/projects/{project}/ai/chat/completions`).
+
+- Strips fields CDF rejects (`max_tokens`, `tool_choice`, `stream_options`, tool `parameters.$schema`, …).
+- Normalizes **CDF camelCase** responses to **OpenAI-style snake_case** for the AI SDK.
+
+Derived from [cognitedata/atlascode PR #1](https://github.com/cognitedata/atlascode/pull/1).
+
+## OpenCode `opencode.json`
+
+```json
+{
+  "provider": {
+    "cdf": {
+      "name": "CDF",
+      "npm": "@andershaf/testopencode",
+      "models": {
+        "azure/gpt-5.1": {
+          "name": "GPT-5.1",
+          "id": "azure/gpt-5.1",
+          "tool_call": true
+        }
+      },
+      "options": {
+        "cluster": "api",
+        "project": "your-project",
+        "token": "{env:CDF_TOKEN}",
+        "headers": {
+          "cdf-version": "20230101-alpha"
+        }
+      }
+    }
+  },
+  "model": "cdf/azure/gpt-5.1"
+}
+```
+
+## Publish
+
+```bash
+cd packages/testopencode
+npm install
+npm run build
+npm publish --access public
+```
+
+Use an npm account with access to the `@andershaf` scope.
+
+## Develop
+
+```bash
+npm run build
+```

package/dist/provider.d.ts

@@ -0,0 +1,8 @@
+import type { CdfProviderOptions } from "./types.js";
+export declare function sanitizeRequestBody(body: Record<string, any>): {
+    [x: string]: any;
+};
+export declare function normalizeCdfPayload(value: any): any;
+export declare function createCdfProvider(options: CdfProviderOptions): import("@ai-sdk/openai-compatible").OpenAICompatibleProvider<string, string, string, string>;
+export default createCdfProvider;
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAsCpD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;EAsC5D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAenD;AAgGD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,gGAoC5D;AAED,eAAe,iBAAiB,CAAA"}

package/dist/provider.js

@@ -0,0 +1,186 @@
+/**
+ * CDF Atlas-style OpenCode provider: sanitize outbound bodies for strict CDF AI,
+ * normalize camelCase responses for OpenCode / AI SDK.
+ *
+ * Based on cognitedata/atlascode (PR #1) + cdf-version header merge.
+ * @see https://github.com/cognitedata/atlascode/pull/1
+ */
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+const CDF_TO_OPENAI_KEY_MAP = {
+    acceptedPredictionTokens: "accepted_prediction_tokens",
+    cachedTokens: "cached_tokens",
+    completionTokens: "completion_tokens",
+    completionTokensDetails: "completion_tokens_details",
+    extraContent: "extra_content",
+    finishReason: "finish_reason",
+    promptTokens: "prompt_tokens",
+    promptTokensDetails: "prompt_tokens_details",
+    reasoningContent: "reasoning_content",
+    reasoningTokens: "reasoning_tokens",
+    rejectedPredictionTokens: "rejected_prediction_tokens",
+    thoughtSignature: "thought_signature",
+    toolCalls: "tool_calls",
+    totalTokens: "total_tokens",
+};
+const CDF_MISSING_TOKEN_MESSAGE = "CDF provider is missing an access token. Set CDF_TOKEN in your environment and restart OpenCode, or configure provider.options.token / an Authorization: Bearer ... header for the cdf provider.";
+function stripUnsupportedSchemaFields(value) {
+    if (Array.isArray(value)) {
+        return value.map(stripUnsupportedSchemaFields);
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value)
+            .filter(([key]) => key !== "$schema" && key !== "ref")
+            .map(([key, nested]) => [key, stripUnsupportedSchemaFields(nested)]);
+        return Object.fromEntries(entries);
+    }
+    return value;
+}
+export function sanitizeRequestBody(body) {
+    const { max_tokens, stream_options, tool_choice, reasoningSummary, reasoning_effort, top_p, verbosity, ...rest } = body;
+    if (rest.tools) {
+        rest.tools = rest.tools.map((tool) => {
+            if (!tool.function?.parameters)
+                return tool;
+            return {
+                ...tool,
+                function: {
+                    ...tool.function,
+                    parameters: stripUnsupportedSchemaFields(tool.function.parameters),
+                },
+            };
+        });
+    }
+    if (rest.messages) {
+        rest.messages = rest.messages.map(({ cache_control, reasoning_content, ...msg }) => {
+            if (Array.isArray(msg.content)) {
+                msg.content = msg.content.map(({ cache_control: _, ...part }) => part);
+            }
+            if (Array.isArray(msg.tool_calls)) {
+                msg.tool_calls = msg.tool_calls.map(({ cache_control: _, ...toolCall }) => toolCall);
+            }
+            return msg;
+        });
+    }
+    return rest;
+}
+export function normalizeCdfPayload(value) {
+    if (Array.isArray(value)) {
+        return value.map(normalizeCdfPayload);
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, nested]) => [
+            CDF_TO_OPENAI_KEY_MAP[key] ?? key,
+            normalizeCdfPayload(nested),
+        ]));
+    }
+    return value;
+}
+function copyResponseHeaders(response, contentType) {
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    if (contentType)
+        headers.set("content-type", contentType);
+    return headers;
+}
+function transformJsonlToEventStream(stream) {
+    const encoder = new TextEncoder();
+    let buffer = "";
+    return stream
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            buffer += chunk;
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                const normalized = normalizeCdfPayload(JSON.parse(trimmed));
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify(normalized)}\n\n`));
+            }
+        },
+        flush(controller) {
+            const trimmed = buffer.trim();
+            if (!trimmed)
+                return;
+            const normalized = normalizeCdfPayload(JSON.parse(trimmed));
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(normalized)}\n\n`));
+        },
+    }));
+}
+async function normalizeCdfResponse(response) {
+    if (!response.ok)
+        return response;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/jsonl") && response.body) {
+        return new Response(transformJsonlToEventStream(response.body), {
+            status: response.status,
+            statusText: response.statusText,
+            headers: copyResponseHeaders(response, "text/event-stream"),
+        });
+    }
+    if (!contentType.includes("application/json")) {
+        return response;
+    }
+    const text = await response.text();
+    const normalized = normalizeCdfPayload(JSON.parse(text));
+    return new Response(JSON.stringify(normalized), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: copyResponseHeaders(response, "application/json"),
+    });
+}
+function getBearerToken(headers) {
+    if (!headers)
+        return undefined;
+    const value = new Headers(headers).get("Authorization");
+    if (!value)
+        return undefined;
+    const match = /^Bearer\s+(.+)$/i.exec(value);
+    return match?.[1];
+}
+function createMissingTokenResponse() {
+    return new Response(JSON.stringify({
+        error: {
+            message: CDF_MISSING_TOKEN_MESSAGE,
+            code: "missing_token",
+        },
+    }), {
+        status: 401,
+        headers: {
+            "content-type": "application/json",
+        },
+    });
+}
+export function createCdfProvider(options) {
+    const { cluster, project, baseURL, name = "cdf", token, headers: extraHeaders } = options;
+    const staticToken = token ?? getBearerToken(extraHeaders);
+    const resolvedBaseURL = baseURL ?? `https://${cluster}.cognitedata.com/api/v1/projects/${project}/ai`;
+    return createOpenAICompatible({
+        name,
+        apiKey: "cdf",
+        baseURL: resolvedBaseURL,
+        fetch: (async (input, init) => {
+            if (!staticToken) {
+                return createMissingTokenResponse();
+            }
+            const headers = new Headers(init?.headers);
+            if (extraHeaders) {
+                new Headers(extraHeaders).forEach((value, key) => {
+                    if (key.toLowerCase() !== "authorization") {
+                        headers.set(key, value);
+                    }
+                });
+            }
+            headers.set("Authorization", `Bearer ${staticToken}`);
+            let body = init?.body;
+            if (typeof body === "string") {
+                body = JSON.stringify(sanitizeRequestBody(JSON.parse(body)));
+            }
+            const response = await globalThis.fetch(input, { ...init, headers, body });
+            return normalizeCdfResponse(response);
+        }),
+    });
+}
+export default createCdfProvider;

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Based on cognitedata/atlascode (PR #1).
+ * @see https://github.com/cognitedata/atlascode/pull/1
+ */
+export interface CdfProviderOptions {
+    /** CDF cluster (e.g. "api", "westeurope-1"). Required unless baseURL is set. */
+    cluster: string;
+    /** CDF project name. Required unless baseURL is set. */
+    project: string;
+    /** OAuth access token for CDF API calls. */
+    token?: string;
+    /**
+     * Extra headers (e.g. cdf-version). If Authorization is set, bearer is used as token.
+     */
+    headers?: HeadersInit;
+    /**
+     * Chat API base URL.
+     * @default https://${cluster}.cognitedata.com/api/v1/projects/${project}/ai
+     */
+    baseURL?: string;
+    /** Provider display name in OpenCode. @default "cdf" */
+    name?: string;
+    defaultModel?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,gFAAgF;IAChF,OAAO,EAAE,MAAM,CAAA;IAEf,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAA;IAEf,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd;;OAEG;IACH,OAAO,CAAC,EAAE,WAAW,CAAA;IAErB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAEhB,wDAAwD;IACxD,IAAI,CAAC,EAAE,MAAM,CAAA;IAEb,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@andershaf/testopencode",
+  "version": "0.1.0",
+  "description": "OpenCode provider for CDF project AI chat (atlascode-style request sanitize + response normalize)",
+  "type": "module",
+  "main": "./dist/provider.js",
+  "types": "./dist/provider.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/provider.d.ts",
+      "import": "./dist/provider.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "opencode",
+    "cognite",
+    "cdf",
+    "ai-sdk"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cognitedata/atlascode.git"
+  },
+  "dependencies": {
+    "@ai-sdk/openai-compatible": "^1.0.34",
+    "@ai-sdk/provider-utils": "^3.0.22"
+  },
+  "peerDependencies": {
+    "@ai-sdk/provider": "^2.0.0",
+    "zod": "^3.25.76 || ^4.1.8"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.0"
+  }
+}