mirror of
https://github.com/diegosouzapw/OmniRoute.git
synced 2026-11-16 17:09:09 +00:00
Merged. Thank you, @maxmad64bis. The design is what made this easy to carry: gated on a new `telemetry` option that is `z.boolean().default(false)`, inert on a host that has no `aisdk` domain, marking matching inference calls in their options only (filtered by provider and SDK package), no fetch wrapping, no client assignment, and any registration failure degraded to a warning. Five tests, one per property. One thing happened on our side and you should know exactly what: #14370 landed first and rewrote `src/index.ts` against the stable `@opencode/plugin` 2.0.12 contract, which collapses the per-event `aisdk` domains into a single named entry point `ctx.aisdk.hook(name, cb)`. Your registration block was written against the beta callable `ctx.aisdk.sdk(cb)`, so it was re-applied onto the new shape rather than merged as-is — mirroring how #14370 wired the sibling Gemini `"language"` hook. The `"sdk"` event on the stable contract carries exactly the three fields your callback already read (`model` / `package` / `options`), so nothing was lost: **the callback body is unchanged**. In the test file, every `it(...)` body and every assertion is byte-identical to yours. Only the host fake moved, and only because it had to: `ctx.catalog` → `ctx.provider` + `ctx.model` (the tip's `assertContext` now requires those transforms and no longer knows `catalog`), and the two callable domains → one `hook(name, cb)` router — the same fake the tip's own `gemini-language.test.ts` uses. The header comment was updated where it cited the old contract version. Validation before merge: `telemetry-sdk-hook.test.ts` 5 pass / 0 fail; the full `@omniroute/opencode-plugin-v2` suite 244 pass / 0 fail across 65 suites (= #14370's 239 plus your 5); `npm run build` and `tsc --noEmit` over src + tests under `strict: true` both exit 0; `typecheck:core`, `check:file-size` and `check:changelog-integrity` green. The net change to `index.ts` is purely additive — the few removed lines are prettier reflow of #14370's own lines.
134 lines
4.8 KiB
TypeScript
134 lines
4.8 KiB
TypeScript
import { describe, it } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import plugin from "../src/index.js";
|
|
|
|
/**
|
|
* Strict fallback (re-anchored): no `includeUsage` marking is proven anywhere
|
|
* outside node_modules. The repo-verifiable facts are:
|
|
* (a) the host mock in `gemini-language.test.ts` mounts a callable `aisdk`
|
|
* domain the plugin reaches through `hook(name, cb)` — the domain exists
|
|
* on the host and routes by name;
|
|
* (b) `@opencode/plugin 2.0.12` is the pinned contract reference
|
|
* (`package.json`), its `sdk`-event option shape is UNKNOWN here.
|
|
* Consequence: no options-only marking is proven → strict fallback: register
|
|
* the hook (domain exists, probed at runtime) and record the observation in
|
|
* `options` only; the pure telemetry core stays unported and unimported.
|
|
*
|
|
* Host shape: the stable `@opencode/plugin` contract publishes the catalog
|
|
* through `ctx.provider.transform` (`assertContext` requires the provider and
|
|
* model transforms) and exposes one named `ctx.aisdk.hook(name, cb)` entry
|
|
* point instead of a callable domain per event. The fake below mirrors that;
|
|
* the five properties it asserts are unchanged.
|
|
*/
|
|
|
|
interface SdkInput {
|
|
model: { id: string; providerID: string };
|
|
package: string;
|
|
options: Record<string, unknown>;
|
|
}
|
|
|
|
function hostCtx(opts: {
|
|
telemetry?: boolean;
|
|
withAisdk?: boolean;
|
|
sdkImpl?: (
|
|
cb: (input: SdkInput) => void | Promise<void>
|
|
) => Promise<{ dispose: () => Promise<void> }>;
|
|
}): {
|
|
ctx: Record<string, unknown>;
|
|
sdkCallbacks: Array<(input: SdkInput) => void | Promise<void>>;
|
|
} {
|
|
const sdkCallbacks: Array<(input: SdkInput) => void | Promise<void>> = [];
|
|
const registration = Promise.resolve({ dispose: async () => {} });
|
|
const options: Record<string, unknown> = {
|
|
baseURL: "https://gw.example.com",
|
|
providerId: "omni",
|
|
apiKey: "k",
|
|
};
|
|
if (opts.telemetry !== undefined) options["telemetry"] = opts.telemetry;
|
|
const ctx: Record<string, unknown> = {
|
|
options,
|
|
provider: { transform: () => registration, reload: async () => {} },
|
|
model: { transform: () => registration },
|
|
integration: { transform: () => registration },
|
|
};
|
|
if (opts.withAisdk !== false) {
|
|
ctx["aisdk"] = {
|
|
hook: (name: string, cb: (input: SdkInput) => void | Promise<void>) => {
|
|
// The stable host routes every aisdk event through one entry point;
|
|
// "language" is the Gemini sanitiser, only "sdk" is this test's subject.
|
|
if (name !== "sdk") return registration;
|
|
if (opts.sdkImpl !== undefined) return opts.sdkImpl(cb);
|
|
sdkCallbacks.push(cb);
|
|
return registration;
|
|
},
|
|
};
|
|
}
|
|
return { ctx, sdkCallbacks };
|
|
}
|
|
|
|
async function setupQuiet(ctx: Record<string, unknown>): Promise<void> {
|
|
const warn = console.warn;
|
|
const log = console.log;
|
|
console.warn = () => {};
|
|
console.log = () => {};
|
|
try {
|
|
await (plugin as unknown as { setup: (c: unknown) => Promise<void> }).setup(ctx);
|
|
} finally {
|
|
console.warn = warn;
|
|
console.log = log;
|
|
}
|
|
}
|
|
|
|
describe("aisdk.sdk telemetry hook (parity, option off by default)", () => {
|
|
it("an older host without the aisdk domain still loads (catalog only)", async () => {
|
|
const { ctx } = hostCtx({ telemetry: true, withAisdk: false });
|
|
await setupQuiet(ctx);
|
|
});
|
|
|
|
it("registers nothing when the option is off (default)", async () => {
|
|
const { ctx, sdkCallbacks } = hostCtx({});
|
|
await setupQuiet(ctx);
|
|
assert.equal(sdkCallbacks.length, 0, "telemetry off must not touch aisdk.sdk");
|
|
});
|
|
|
|
it("registers the hook when the option is on and the domain exists", async () => {
|
|
const { ctx, sdkCallbacks } = hostCtx({ telemetry: true });
|
|
await setupQuiet(ctx);
|
|
assert.equal(sdkCallbacks.length, 1, "telemetry on must register aisdk.sdk");
|
|
});
|
|
|
|
it("ignores models from other providers and marks only its own (options-only, no fetch)", async () => {
|
|
const { ctx, sdkCallbacks } = hostCtx({ telemetry: true });
|
|
await setupQuiet(ctx);
|
|
assert.equal(sdkCallbacks.length, 1);
|
|
const foreign: SdkInput = {
|
|
model: { id: "m", providerID: "some-other-provider" },
|
|
package: "@ai-sdk/openai-compatible",
|
|
options: {},
|
|
};
|
|
await sdkCallbacks[0]!(foreign);
|
|
assert.deepEqual(foreign.options, {}, "another provider's options are untouched");
|
|
const own: SdkInput = {
|
|
model: { id: "m", providerID: "omni" },
|
|
package: "@ai-sdk/openai-compatible",
|
|
options: {},
|
|
};
|
|
await sdkCallbacks[0]!(own);
|
|
assert.equal(
|
|
own.options["telemetry"],
|
|
true,
|
|
"own models carry an options-only telemetry mark, never a wrapped fetch"
|
|
);
|
|
});
|
|
|
|
it("a host that refuses the sdk hook still keeps its catalog", async () => {
|
|
const { ctx } = hostCtx({
|
|
telemetry: true,
|
|
sdkImpl: () => {
|
|
throw new Error("refused");
|
|
},
|
|
});
|
|
await setupQuiet(ctx);
|
|
});
|
|
});
|