@opencode-compat/host-promise-v2 0.1.0

package/README.md

@@ -0,0 +1,40 @@
+# @opencode-compat/host-promise-v2
+
+Shared Promise v2 aisdk host kit wired from the OCP layer.
+
+Matches OpenCode `@opencode-ai/plugin/v2/promise` shape:
+
+```ts
+import {
+  createPromiseV2Host,
+  define,
+} from "@opencode-compat/host-promise-v2"
+
+const plugin = define({
+  id: "demo",
+  async setup(ctx) {
+    await ctx.aisdk.sdk(async (event) => {
+      // event.sdk = …
+    })
+    await ctx.aisdk.language(async (event) => {
+      // event.language = LanguageModelV3
+    })
+  },
+})
+
+const host = createPromiseV2Host()
+await host.register(plugin)
+const { language, sdk } = await host.resolveProvider({
+  providerID: "demo",
+  modelID: "m1",
+  package: "demo-pkg",
+})
+```
+
+Adapter helper: `wirePromiseV2()` from `@opencode-compat/adapter` / `@opencode-compat/ocp`.
+
+On MiMo/Kilo there is **no** native in-process aisdk emit yet — operators call `resolveProvider` from an external sidecar after Layer A setup. See [`docs/hosts/mimo.md`](../../docs/hosts/mimo.md) §3 (copy-paste smoke + success criteria).
+
+**License:** MPL-2.0
+
+See the monorepo [README](../../README.md) and [OCP 0.1](../../docs/ocp/0.1.md).

package/dist/index.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Shared Promise v2 aisdk host kit — wired from the OCP layer
+ * (operator overrides / sidecar / host-kit helpers).
+ *
+ * API shape matches `@opencode-ai/plugin/v2/promise` (OpenCode 1.18.x):
+ * `await ctx.aisdk.sdk(cb)` / `await ctx.aisdk.language(cb)`.
+ *
+ * OCP 0.1 T3 bar: `ctx.aisdk` language (+ ideally sdk) hooks.
+ * Other domains loud-stub in the same ship.
+ */
+export declare const PKG: "@opencode-compat/host-promise-v2";
+export declare const VERSION: "0.1.0";
+export type Registration = {
+    readonly dispose: () => Promise<void>;
+};
+export type Reload = {
+    readonly reload: () => Promise<void>;
+};
+/** Minimal LanguageModelV3-shaped stand-in for conformance (not a full AI SDK type). */
+export type LanguageModelV3Like = {
+    specificationVersion: "v3";
+    provider: string;
+    modelId: string;
+    [key: string]: unknown;
+};
+/**
+ * Minimal ModelV2Info stand-in (OpenCode sdk/v2). Full upstream type is large;
+ * plugins typically read `providerID`, `id`, and `api.id`.
+ */
+export type ModelV2InfoLike = {
+    id: string;
+    providerID: string;
+    name?: string;
+    api: {
+        id: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+};
+export type SdkEvent = {
+    readonly model: ModelV2InfoLike;
+    readonly package: string;
+    readonly options: Record<string, unknown>;
+    sdk?: unknown;
+};
+export type LanguageEvent = {
+    readonly model: ModelV2InfoLike;
+    readonly sdk: unknown;
+    readonly options: Record<string, unknown>;
+    language?: LanguageModelV3Like | unknown;
+};
+type HookCallback<E> = (event: E) => void | Promise<void>;
+export type AisdkHooks = {
+    /** Register an aisdk `sdk` hook (OpenCode Promise v2 shape). */
+    sdk: (callback: HookCallback<SdkEvent>) => Promise<Registration>;
+    /** Register an aisdk `language` hook (OpenCode Promise v2 shape). */
+    language: (callback: HookCallback<LanguageEvent>) => Promise<Registration>;
+    /** Host diagnostics: number of listeners for a named hook. */
+    listenerCount(event: "sdk" | "language"): number;
+    /** Host diagnostics: events that currently have listeners. */
+    events(): Array<"sdk" | "language">;
+};
+export type Plugin = {
+    readonly id: string;
+    readonly setup: (context: PluginContext) => Promise<void> | void;
+};
+/** @deprecated Prefer `Plugin` (OpenCode name). */
+export type PromisePlugin = Plugin;
+export type PluginDomain = {
+    readonly add: (plugin: Plugin) => Promise<void>;
+    readonly remove: (id: string) => Promise<void>;
+};
+export type PluginContext = {
+    readonly options: Record<string, unknown>;
+    readonly aisdk: AisdkHooks;
+    readonly plugin: PluginDomain & {
+        id?: string;
+        [key: string]: unknown;
+    };
+    /** Loud stubs for T4 domains until wired */
+    readonly agent: LoudDomain & Reload;
+    readonly catalog: LoudDomain & Reload;
+    readonly command: LoudDomain & Reload;
+    readonly skill: LoudDomain & Reload;
+    readonly reference: LoudDomain & Reload;
+    readonly integration: LoudDomain & Reload;
+};
+type LoudDomain = {
+    [key: string]: (...args: unknown[]) => never;
+};
+export type LanguageModelInput = {
+    providerID: string;
+    modelID: string;
+    package?: string;
+    options?: Record<string, unknown>;
+    sdk?: unknown;
+    model?: Partial<ModelV2InfoLike>;
+    [key: string]: unknown;
+};
+export type PromiseV2Host = {
+    readonly ctx: PluginContext;
+    /** Register + run `setup` for a Promise v2 plugin. */
+    register(plugin: Plugin): Promise<Plugin>;
+    /** Remove a previously registered plugin by id. */
+    remove(id: string): Promise<void>;
+    /** Provider-resolve: run sdk then language hooks; return mutated fields. */
+    resolveProvider(input: LanguageModelInput): Promise<{
+        language?: unknown;
+        sdk: unknown;
+        model: ModelV2InfoLike;
+    }>;
+    /** List plugin ids currently registered via `plugin.add` / `register`. */
+    plugins(): string[];
+};
+/**
+ * Create an OCP-layer Promise v2 host.
+ * Call `register` for each v2 plugin, then `resolveProvider` at provider-resolve time.
+ */
+export declare function createPromiseV2Host(options?: Record<string, unknown>): PromiseV2Host;
+/** @deprecated Prefer `createPromiseV2Host().ctx.aisdk`. */
+export declare function createAisdkBus(): AisdkHooks;
+/** Create a PluginContext for the OCP layer / hosts that wire this kit. */
+export declare function createPluginContext(options?: Record<string, unknown>, plugin?: {
+    id?: string;
+    [key: string]: unknown;
+}): PluginContext;
+/**
+ * Promise v2 `define()` — identity + validation (OpenCode-compatible).
+ * The OCP layer / host must `register` / invoke `setup` at load time.
+ */
+export declare function define(plugin: Plugin): Plugin;
+export declare function isPromisePlugin(value: unknown): value is Plugin;
+/** Run plugin setup against a fresh OCP-layer host (conformance helper). */
+export declare function runPromisePlugin(plugin: Plugin, init?: {
+    options?: Record<string, unknown>;
+}): Promise<{
+    host: PromiseV2Host;
+    ctx: PluginContext;
+    plugin: Plugin;
+}>;
+/**
+ * Host provider-resolve helper: emit `sdk` then `language` against ctx listeners.
+ * Prefer `createPromiseV2Host().resolveProvider` when you own the host.
+ */
+export declare function injectLanguageModel(ctx: PluginContext, input?: LanguageModelInput): Promise<{
+    language?: unknown;
+    sdk?: unknown;
+}>;
+/** Emit `aisdk` `sdk` hook (optional T3 companion). */
+export declare function injectSdk(ctx: PluginContext, input?: LanguageModelInput, seed?: {
+    sdk?: unknown;
+}): Promise<{
+    sdk?: unknown;
+}>;
+/** Full host resolve path: language + sdk hooks on an existing ctx. */
+export declare function resolveProvider(ctx: PluginContext, input: LanguageModelInput): Promise<{
+    language?: unknown;
+    sdk: unknown;
+}>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,264 @@
+/**
+ * Shared Promise v2 aisdk host kit — wired from the OCP layer
+ * (operator overrides / sidecar / host-kit helpers).
+ *
+ * API shape matches `@opencode-ai/plugin/v2/promise` (OpenCode 1.18.x):
+ * `await ctx.aisdk.sdk(cb)` / `await ctx.aisdk.language(cb)`.
+ *
+ * OCP 0.1 T3 bar: `ctx.aisdk` language (+ ideally sdk) hooks.
+ * Other domains loud-stub in the same ship.
+ */
+export const PKG = "@opencode-compat/host-promise-v2";
+export const VERSION = "0.1.0";
+const ctxInternal = new WeakMap();
+function loudDomain(name) {
+    const reload = async () => {
+        throw new Error(`${PKG}: Promise v2 domain "${name}" reload is not implemented. See docs/ocp/0.1.md §7.`);
+    };
+    return new Proxy({ reload }, {
+        get(target, prop) {
+            if (prop === "reload")
+                return target.reload;
+            if (prop === Symbol.toStringTag)
+                return `LoudDomain(${name})`;
+            return (..._args) => {
+                throw new Error(`${PKG}: Promise v2 domain "${name}" is not implemented (called: ${String(prop)}). See docs/ocp/0.1.md §7.`);
+            };
+        },
+    });
+}
+function createAisdkInternal() {
+    const sdkHandlers = new Set();
+    const languageHandlers = new Set();
+    const hooks = {
+        async sdk(callback) {
+            sdkHandlers.add(callback);
+            return {
+                async dispose() {
+                    sdkHandlers.delete(callback);
+                },
+            };
+        },
+        async language(callback) {
+            languageHandlers.add(callback);
+            return {
+                async dispose() {
+                    languageHandlers.delete(callback);
+                },
+            };
+        },
+        listenerCount(event) {
+            return event === "sdk" ? sdkHandlers.size : languageHandlers.size;
+        },
+        events() {
+            const out = [];
+            if (sdkHandlers.size > 0)
+                out.push("sdk");
+            if (languageHandlers.size > 0)
+                out.push("language");
+            return out;
+        },
+    };
+    return {
+        hooks,
+        async emitSdk(event) {
+            for (const handler of [...sdkHandlers]) {
+                await handler(event);
+            }
+            return event;
+        },
+        async emitLanguage(event) {
+            for (const handler of [...languageHandlers]) {
+                await handler(event);
+            }
+            return event;
+        },
+    };
+}
+function modelFromInput(input) {
+    const providerID = String(input.providerID ?? input.model?.providerID ?? "");
+    const modelID = String(input.modelID ?? input.model?.id ?? "");
+    return {
+        id: modelID,
+        providerID,
+        name: input.model?.name ?? modelID,
+        api: { id: modelID, ...(input.model?.api ?? {}) },
+        ...input.model,
+    };
+}
+function buildHost(options) {
+    const aisdk = createAisdkInternal();
+    const plugins = new Map();
+    const state = {
+        plugins,
+        aisdk,
+        options,
+        ctx: null,
+    };
+    const pluginDomain = {
+        async add(plugin) {
+            await registerOnHost(state, plugin);
+        },
+        async remove(id) {
+            state.plugins.delete(id);
+        },
+    };
+    const ctx = {
+        options,
+        aisdk: aisdk.hooks,
+        plugin: pluginDomain,
+        agent: loudDomain("agent"),
+        catalog: loudDomain("catalog"),
+        command: loudDomain("command"),
+        skill: loudDomain("skill"),
+        reference: loudDomain("reference"),
+        integration: loudDomain("integration"),
+    };
+    state.ctx = ctx;
+    ctxInternal.set(ctx, aisdk);
+    return state;
+}
+async function registerOnHost(state, plugin) {
+    const defined = define(plugin);
+    state.plugins.set(defined.id, defined);
+    state.ctx.plugin.id = defined.id;
+    await defined.setup(state.ctx);
+    return defined;
+}
+async function resolveOnHost(state, input) {
+    const model = modelFromInput(input);
+    const pkg = String(input.package ?? "");
+    const opts = { ...(input.options ?? {}) };
+    const sdkEvent = {
+        model,
+        package: pkg,
+        options: opts,
+        sdk: input.sdk,
+    };
+    await state.aisdk.emitSdk(sdkEvent);
+    const languageEvent = {
+        model,
+        sdk: sdkEvent.sdk,
+        options: opts,
+        language: undefined,
+    };
+    await state.aisdk.emitLanguage(languageEvent);
+    return {
+        language: languageEvent.language,
+        sdk: sdkEvent.sdk,
+        model,
+    };
+}
+/**
+ * Create an OCP-layer Promise v2 host.
+ * Call `register` for each v2 plugin, then `resolveProvider` at provider-resolve time.
+ */
+export function createPromiseV2Host(options = {}) {
+    const state = buildHost(options);
+    return {
+        ctx: state.ctx,
+        async register(plugin) {
+            return registerOnHost(state, plugin);
+        },
+        async remove(id) {
+            state.plugins.delete(id);
+        },
+        async resolveProvider(input) {
+            return resolveOnHost(state, input);
+        },
+        plugins() {
+            return [...state.plugins.keys()];
+        },
+    };
+}
+/** @deprecated Prefer `createPromiseV2Host().ctx.aisdk`. */
+export function createAisdkBus() {
+    return createAisdkInternal().hooks;
+}
+/** Create a PluginContext for the OCP layer / hosts that wire this kit. */
+export function createPluginContext(options = {}, plugin = {}) {
+    const host = createPromiseV2Host(options);
+    if (plugin.id)
+        host.ctx.plugin.id = plugin.id;
+    for (const [key, value] of Object.entries(plugin)) {
+        if (key === "id")
+            continue;
+        host.ctx.plugin[key] = value;
+    }
+    return host.ctx;
+}
+/**
+ * Promise v2 `define()` — identity + validation (OpenCode-compatible).
+ * The OCP layer / host must `register` / invoke `setup` at load time.
+ */
+export function define(plugin) {
+    if (!plugin || typeof plugin.setup !== "function") {
+        throw new Error(`${PKG}: define() requires { id, setup(ctx) }`);
+    }
+    if (typeof plugin.id !== "string" || plugin.id.length === 0) {
+        throw new Error(`${PKG}: define() requires a non-empty string id`);
+    }
+    return plugin;
+}
+export function isPromisePlugin(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.setup === "function" &&
+        typeof value.id === "string");
+}
+/** Run plugin setup against a fresh OCP-layer host (conformance helper). */
+export async function runPromisePlugin(plugin, init) {
+    const host = createPromiseV2Host(init?.options ?? {});
+    const defined = await host.register(plugin);
+    return { host, ctx: host.ctx, plugin: defined };
+}
+function requireInternal(ctx) {
+    const internal = ctxInternal.get(ctx);
+    if (!internal) {
+        throw new Error(`${PKG}: PluginContext was not created by this host kit. ` +
+            "Use createPromiseV2Host() / runPromisePlugin() / createPluginContext().");
+    }
+    return internal;
+}
+/**
+ * Host provider-resolve helper: emit `sdk` then `language` against ctx listeners.
+ * Prefer `createPromiseV2Host().resolveProvider` when you own the host.
+ */
+export async function injectLanguageModel(ctx, input = { providerID: "", modelID: "" }) {
+    const internal = requireInternal(ctx);
+    const model = modelFromInput(input);
+    const opts = { ...(input.options ?? {}) };
+    const sdkEvent = {
+        model,
+        package: String(input.package ?? ""),
+        options: opts,
+        sdk: input.sdk,
+    };
+    await internal.emitSdk(sdkEvent);
+    const languageEvent = {
+        model,
+        sdk: sdkEvent.sdk,
+        options: opts,
+    };
+    await internal.emitLanguage(languageEvent);
+    return { language: languageEvent.language, sdk: sdkEvent.sdk };
+}
+/** Emit `aisdk` `sdk` hook (optional T3 companion). */
+export async function injectSdk(ctx, input = { providerID: "", modelID: "" }, seed = {}) {
+    const internal = requireInternal(ctx);
+    const model = modelFromInput(input);
+    const sdkEvent = {
+        model,
+        package: String(input.package ?? ""),
+        options: { ...(input.options ?? {}) },
+        sdk: seed.sdk ?? input.sdk,
+    };
+    await internal.emitSdk(sdkEvent);
+    return { sdk: sdkEvent.sdk };
+}
+/** Full host resolve path: language + sdk hooks on an existing ctx. */
+export async function resolveProvider(ctx, input) {
+    const out = await injectLanguageModel(ctx, input);
+    return { language: out.language, sdk: out.sdk };
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@opencode-compat/host-promise-v2",
+  "version": "0.1.0",
+  "description": "Shared Promise v2 aisdk host kit wired from the OCP layer",
+  "type": "module",
+  "license": "MPL-2.0",
+  "author": "oakimov",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oakimov/opencode-plugin-compat.git",
+    "directory": "packages/host-promise-v2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "!dist/**/*.map"
+  ],
+  "scripts": {
+    "build": "bunx tsc -p tsconfig.json",
+    "typecheck": "bunx tsc -p tsconfig.json --noEmit",
+    "prepack": "bunx tsc -p tsconfig.json"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "bugs": {
+    "url": "https://github.com/oakimov/opencode-plugin-compat/issues"
+  },
+  "homepage": "https://github.com/oakimov/opencode-plugin-compat/tree/main/packages/host-promise-v2#readme",
+  "keywords": [
+    "opencode",
+    "ocp",
+    "aisdk",
+    "promise-v2"
+  ],
+  "engines": {
+    "bun": ">=1.2.0"
+  }
+}