@opencode/ai 0.0.0-reserved → 2.0.1

package/dist/testing.js

@@ -0,0 +1,129 @@
+export * as TestLLM from "./testing.js";
+import { LLMClient, } from "./route/client.js";
+import { LLMEvent, LLMResponse, CompactionResponse, CompactionCheckpointResponse, } from "./schema/index.js";
+import { Context, Deferred, Effect, Latch, Layer, Queue, Scope, Stream } from "effect";
+export class Test extends Context.Service()("@opencode/ai/TestLLM/Test") {
+}
+/** @deprecated Use Test and testLayer for normal client methods and test controls. */
+export class Service extends Context.Service()("@opencode/ai/TestLLM") {
+}
+export const complete = (options, ...events) => [
+    LLMEvent.stepStart({ index: 0 }),
+    ...events,
+    LLMEvent.stepFinish({
+        index: 0,
+        reason: options.reason,
+        usage: options.usage,
+        providerMetadata: options.providerMetadata,
+    }),
+    LLMEvent.finish({ reason: options.reason, providerMetadata: options.providerMetadata }),
+];
+export const stop = (...events) => complete({ reason: { normalized: "stop" } }, ...events);
+export const toolCalls = (...events) => complete({ reason: { normalized: "tool-calls" } }, ...events);
+const textEvents = (value, id) => [
+    LLMEvent.textStart({ id }),
+    LLMEvent.textDelta({ id, text: value }),
+    LLMEvent.textEnd({ id }),
+];
+export const text = (value, id) => stop(...textEvents(value, id));
+export const textWithUsage = (value, id, inputTokens) => complete({ reason: { normalized: "stop" }, usage: { inputTokens, nonCachedInputTokens: inputTokens } }, ...textEvents(value, id));
+export const tool = (id, name, input) => toolCalls(LLMEvent.toolCall({ id, name, input }));
+export const failAfter = (error, ...events) => Stream.fromIterable(events).pipe(Stream.concat(Stream.fail(error)));
+export const hangAfter = (...events) => Stream.concat(Stream.fromIterable(events), Stream.never);
+const make = (options) => Effect.sync(() => {
+    const requests = [];
+    const responses = [];
+    let started = Deferred.makeUnsafe();
+    let fallback = options.fallback;
+    let activeGate;
+    const wait = (count) => Effect.suspend(() => requests.length >= count ? Effect.void : Deferred.await(started).pipe(Effect.andThen(wait(count))));
+    const take = (request) => Effect.suspend(() => {
+        const count = requests.push(options.transformRequest?.(request) ?? request);
+        const waiting = started;
+        started = Deferred.makeUnsafe();
+        const gate = activeGate;
+        try {
+            const response = responses.shift() ?? (typeof fallback === "function" ? fallback(request) : fallback);
+            if (!response)
+                return Effect.die(new Error(`TestLLM has no response for request ${count}`));
+            if (!gate)
+                return Effect.succeed(response);
+            return Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(response));
+        }
+        finally {
+            // Waiters can resume synchronously; assign the reply and gate before notifying them.
+            Deferred.doneUnsafe(waiting, Effect.void);
+        }
+    });
+    const stream = (request) => Stream.unwrap(take(request).pipe(Effect.map((response) => {
+        if (response instanceof CompactionResponse || response instanceof CompactionCheckpointResponse)
+            return Stream.die("TestLLM generation requires an event response");
+        return Stream.isStream(response) ? response : Stream.fromIterable(response);
+    })));
+    function compact(request, options) {
+        return take(request).pipe(Effect.flatMap((response) => {
+            if (options?.mechanism === "trigger")
+                return response instanceof CompactionCheckpointResponse
+                    ? Effect.succeed(response)
+                    : Effect.die("TestLLM trigger compaction requires a CompactionCheckpointResponse");
+            return response instanceof CompactionResponse
+                ? Effect.succeed(response)
+                : Effect.die("TestLLM compaction requires a CompactionResponse");
+        }));
+    }
+    const test = Test.of({
+        compact,
+        stream,
+        generate: (request) => stream(request).pipe(Stream.runFold(LLMResponse.empty, LLMResponse.reduce), Effect.flatMap((state) => {
+            const response = LLMResponse.complete(state);
+            if (response)
+                return Effect.succeed(response);
+            return Effect.die("TestLLM response ended without a terminal finish event");
+        })),
+        requests: () => Effect.sync(() => [...requests]),
+        push: (...input) => Effect.sync(() => {
+            responses.push(...input);
+        }),
+        always: (response) => Effect.sync(() => {
+            fallback = response;
+        }),
+        serve: (responder) => Effect.sync(() => {
+            fallback = responder;
+        }),
+        wait,
+        gate: () => Effect.gen(function* () {
+            const gate = {
+                started: yield* Effect.acquireRelease(Queue.unbounded(), Queue.shutdown),
+                release: yield* Latch.make(),
+            };
+            activeGate = gate;
+            const release = Effect.sync(() => {
+                if (activeGate === gate)
+                    activeGate = undefined;
+            }).pipe(Effect.andThen(gate.release.open), Effect.asVoid);
+            yield* Effect.addFinalizer(() => release);
+            return {
+                started: Queue.take(gate.started),
+                release,
+            };
+        }),
+    });
+    return { test, requests };
+});
+/** Provides one shared implementation under the normal client and test-control tags. */
+export const testLayer = (options = {}) => Layer.effectContext(Effect.map(make(options), (implementation) => Context.make(LLMClient.Service, implementation.test).pipe(Context.add(Test, implementation.test))));
+/** @deprecated Use testLayer; retained for published callers of the legacy control interface. */
+export const layer = (options = {}) => Layer.effect(Service, Effect.map(make(options), (implementation) => Service.of({
+    requests: implementation.requests,
+    push: implementation.test.push,
+    always: implementation.test.always,
+    wait: implementation.test.wait,
+    gate: implementation.test.gate(),
+    client: implementation.test,
+})));
+/** @deprecated testLayer provides LLMClient.Service directly. */
+export const clientLayer = Layer.effect(LLMClient.Service, Effect.map(Service, (service) => service.client));
+export const push = (...responses) => Service.use((service) => service.push(...responses));
+export const always = (response) => Service.use((service) => service.always(response));
+export const wait = (count) => Service.use((service) => service.wait(count));
+export const gate = Service.use((service) => service.gate);

package/dist/tool-history.d.ts

@@ -0,0 +1,2 @@
+import { Message } from "./schema/messages.js";
+export declare function normalizeToolHistory(messages: ReadonlyArray<Message>): readonly Message[];

package/dist/tool-history.js

@@ -0,0 +1,84 @@
+import { Message, ToolResultPart } from "./schema/messages.js";
+const EMPTY_TOOL_OUTPUT = "(no tool output)";
+const MISSING_TOOL_RESULT = "Tool result missing";
+export function normalizeToolHistory(messages) {
+    const normalized = [];
+    const pending = new Map();
+    const appendMissingResults = () => {
+        if (pending.size === 0)
+            return;
+        normalized.push(missingToolResults(pending.values()));
+        pending.clear();
+    };
+    for (const message of messages) {
+        if (message.role === "user" || message.role === "assistant")
+            appendMissingResults();
+        if (message.role === "tool") {
+            const tool = normalizeToolMessage(message, pending);
+            if (tool)
+                normalized.push(tool);
+            continue;
+        }
+        normalized.push(message);
+        if (message.role !== "assistant")
+            continue;
+        for (const part of message.content) {
+            if (part.type === "tool-call" && part.providerExecuted !== true)
+                pending.set(part.id, part);
+        }
+    }
+    return normalized.length === messages.length && normalized.every((message, index) => message === messages[index])
+        ? messages
+        : normalized;
+}
+function missingToolResults(calls) {
+    return new Message({
+        role: "tool",
+        content: [...calls].map((call) => ToolResultPart.make({
+            id: call.id,
+            name: call.name,
+            namespace: call.namespace,
+            result: MISSING_TOOL_RESULT,
+            resultType: "error",
+        })),
+    });
+}
+function normalizeToolMessage(message, pending) {
+    const content = message.content.map((part) => {
+        if (part.type !== "tool-result" || part.providerExecuted === true)
+            return part;
+        const call = pending.get(part.id);
+        if (call)
+            pending.delete(part.id);
+        return normalizeToolResult(part, call);
+    });
+    if (content.length === 0)
+        return undefined;
+    if (content.every((part, index) => part === message.content[index]))
+        return message;
+    return new Message({
+        id: message.id,
+        role: message.role,
+        content,
+        metadata: message.metadata,
+        providerMetadata: message.providerMetadata,
+        native: message.native,
+    });
+}
+function normalizeToolResult(part, call) {
+    const named = call === undefined || (part.name === call.name && part.namespace === call.namespace)
+        ? part
+        : { ...part, name: call.name, namespace: call.namespace };
+    if (named.result.type === "text" && named.result.value === "")
+        return { ...named, result: { type: "text", value: EMPTY_TOOL_OUTPUT } };
+    if (named.result.type === "error" && named.result.value === "")
+        return { ...named, result: { type: "error", value: EMPTY_TOOL_OUTPUT } };
+    if (named.result.type !== "content")
+        return named;
+    const value = named.result.value.filter((item) => item.type !== "text" || item.text !== "");
+    if (value.length === 0)
+        return { ...named, result: { type: "text", value: EMPTY_TOOL_OUTPUT } };
+    if (value.length === named.result.value.length)
+        return named;
+    return { ...named, result: { type: "content", value } };
+}

package/dist/tool-runtime.d.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect";
+import { LLMEvent, type ToolCallPart, type ToolOutput as ToolOutputType, type ToolResultValue as ToolResultValueType } from "./schema/index.js";
+import { type Tools } from "./tool.js";
+export interface ToolSettlement {
+    readonly result: ToolResultValueType;
+    readonly output?: ToolOutputType;
+}
+export interface DispatchResult extends ToolSettlement {
+    readonly events: ReadonlyArray<LLMEvent>;
+}
+/** Execute one canonical tool call without owning provider IO or continuation. */
+export declare const dispatch: (tools: Tools, call: ToolCallPart) => Effect.Effect<DispatchResult>;
+export declare const ToolRuntime: {
+    readonly dispatch: (tools: Tools, call: ToolCallPart) => Effect.Effect<DispatchResult>;
+};

package/dist/tool-runtime.js

@@ -0,0 +1,62 @@
+import { Effect } from "effect";
+import { LLMEvent, ToolFailure, ToolOutput, ToolResultValue, } from "./schema/index.js";
+import {} from "./tool.js";
+/** Execute one canonical tool call without owning provider IO or continuation. */
+export const dispatch = (tools, call) => {
+    const name = call.namespace === undefined ? call.name : `${call.namespace}.${call.name}`;
+    const tool = tools[name];
+    if (!tool)
+        return Effect.succeed(result(call, { type: "error", value: `Unknown tool: ${name}` }));
+    if (!tool.execute)
+        return Effect.succeed(result(call, { type: "error", value: `Tool has no execute handler: ${name}` }));
+    return decodeAndExecute(tool, call).pipe(Effect.map((value) => result(call, value)), Effect.catchTag("Tool.Error", (failure) => Effect.succeed(result(call, { type: "error", value: failure.message }, failure.error))));
+};
+const decodeAndExecute = (tool, call) => tool._decode(call.input).pipe(Effect.mapError((error) => new ToolFailure({ message: `Invalid tool input: ${error.message}` })), Effect.flatMap((decoded) => tool.execute(decoded, {
+    id: call.id,
+    name: call.name,
+    namespace: call.namespace,
+}).pipe(Effect.flatMap((value) => tool._encode(value).pipe(Effect.mapError((error) => new ToolFailure({
+    message: `Tool returned an invalid value for its success schema: ${error.message}`,
+})))), Effect.map((encoded) => {
+    if (tool._legacyResult && ToolResultValue.is(encoded))
+        return { result: encoded, output: ToolOutput.fromResultValue(encoded) };
+    const output = tool._project(decoded, call.id, encoded);
+    const result = ToolOutput.toResultValue(output);
+    return result.type === "error" ? { result } : { result, output };
+}))));
+const result = (call, value, error) => {
+    const settlement = ToolResultValue.is(value) ? { result: value } : value;
+    return {
+        result: settlement.result,
+        output: settlement.output,
+        events: settlement.result.type === "error"
+            ? [
+                LLMEvent.toolError({
+                    id: call.id,
+                    name: call.name,
+                    namespace: call.namespace,
+                    message: String(settlement.result.value),
+                    error,
+                    providerMetadata: call.providerMetadata,
+                }),
+                LLMEvent.toolResult({
+                    id: call.id,
+                    name: call.name,
+                    namespace: call.namespace,
+                    result: settlement.result,
+                    providerMetadata: call.providerMetadata,
+                }),
+            ]
+            : [
+                LLMEvent.toolResult({
+                    id: call.id,
+                    name: call.name,
+                    namespace: call.namespace,
+                    result: settlement.result,
+                    output: settlement.output,
+                    providerMetadata: call.providerMetadata,
+                }),
+            ],
+    };
+};
+export const ToolRuntime = { dispatch };

package/dist/tool.d.ts

@@ -0,0 +1,136 @@
+import { Effect, JsonSchema, Schema } from "effect";
+import { Tool } from "@opencode/schema/tool";
+import type { ToolCallPart, ToolDefinition as ToolDefinitionClass, ToolOutput as ToolOutputType } from "./schema/index.js";
+import { ToolFailure } from "./schema/index.js";
+/**
+ * Schema constraint for tool parameters / success values: no decoding or
+ * encoding services are allowed. Tools should be self-contained — anything
+ * beyond pure data conversion belongs in the handler closure.
+ */
+export type ToolSchema<T> = Schema.Codec<T, any, never, never>;
+export interface ToolExecuteContext {
+    readonly id: ToolCallPart["id"];
+    readonly name: ToolCallPart["name"];
+    readonly namespace?: ToolCallPart["namespace"];
+}
+export type ToolExecute<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> = (params: Schema.Schema.Type<Parameters>, context?: ToolExecuteContext) => Effect.Effect<Schema.Schema.Type<Success>, ToolFailure>;
+export interface ToolModelOutputInput<Parameters, Output> {
+    readonly id: ToolCallPart["id"];
+    readonly parameters: Parameters;
+    readonly output: Output;
+}
+export type ToolToModelOutput<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> = (input: ToolModelOutputInput<Schema.Schema.Type<Parameters>, Success["Encoded"]>) => ReadonlyArray<Tool.Content>;
+/**
+ * A type-safe LLM tool. Each tool bundles its own description, parameter
+ * Schema and success Schema. The execute handler is optional: omit it when you
+ * only want to expose a tool schema to the model and handle tool calls outside
+ * this package.
+ *
+ * Errors must be expressed as `ToolFailure`. Unmapped errors and defects fail
+ * the stream.
+ *
+ * Internally each tool also carries memoized codecs and a precomputed
+ * `ToolDefinition` so callers do not rebuild them per invocation.
+ */
+export interface Definition<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> {
+    readonly description: string;
+    readonly parameters: Parameters;
+    readonly success: Success;
+    readonly execute?: ToolExecute<Parameters, Success>;
+    readonly toModelOutput?: ToolToModelOutput<Parameters, Success>;
+    readonly toStructuredOutput?: (output: Success["Encoded"]) => unknown;
+    /** @internal */
+    readonly _decode: (input: unknown) => Effect.Effect<Schema.Schema.Type<Parameters>, Schema.SchemaError>;
+    /** @internal */
+    readonly _encode: (value: Schema.Schema.Type<Success>) => Effect.Effect<unknown, Schema.SchemaError>;
+    /** @internal */
+    readonly _project: (parameters: Schema.Schema.Type<Parameters>, id: ToolCallPart["id"], output: unknown) => ToolOutputType;
+    /** @internal */
+    readonly _legacyResult: boolean;
+    /** @internal */
+    readonly _definition: ToolDefinitionClass;
+}
+export type AnyTool = Definition<any, any>;
+export type ExecutableTool<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> = Definition<Parameters, Success> & {
+    readonly execute: ToolExecute<Parameters, Success>;
+};
+export type AnyExecutableTool = ExecutableTool<any, any>;
+export type ExecutableTools = Record<string, AnyExecutableTool>;
+/**
+ * Constructs a tool. Two input modes:
+ *
+ * 1. **Typed** — pass Effect `parameters` and `success` Schemas; inputs and
+ *    outputs are statically typed and decoded/encoded automatically.
+ *
+ *    ```ts
+ *    Tool.make({
+ *      description: "Get current weather",
+ *      parameters: Schema.Struct({ city: Schema.String }),
+ *      success: Schema.Struct({ temperature: Schema.Number }),
+ *      execute: ({ city }) => Effect.succeed({ temperature: 22 }),
+ *    })
+ *    ```
+ *
+ * 2. **Dynamic** — pass raw JSON Schema as `jsonSchema`. Use this when the
+ *    schema comes from an external source (MCP server, plugin manifest,
+ *    dynamic config) and is not known at compile time. Inputs are typed as
+ *    `unknown`; the handler is responsible for any validation it needs.
+ *
+ *    ```ts
+ *    Tool.make({
+ *      description: "Look something up",
+ *      jsonSchema: { type: "object", properties: { ... } },
+ *      execute: (params) => Effect.succeed(...),
+ *    })
+ *    ```
+ *
+ * In both modes the produced tool flows through `toDefinitions(...)`
+ * identically.
+ */
+export declare function make<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>>(config: {
+    readonly description: string;
+    readonly parameters: Parameters;
+    readonly success: Success;
+    readonly execute: ToolExecute<Parameters, Success>;
+    readonly toModelOutput?: ToolToModelOutput<Parameters, Success>;
+    readonly toStructuredOutput?: (output: Success["Encoded"]) => unknown;
+}): ExecutableTool<Parameters, Success>;
+export declare function make<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>>(config: {
+    readonly description: string;
+    readonly parameters: Parameters;
+    readonly success: Success;
+    readonly execute?: undefined;
+    readonly toModelOutput?: ToolToModelOutput<Parameters, Success>;
+    readonly toStructuredOutput?: (output: Success["Encoded"]) => unknown;
+}): Definition<Parameters, Success>;
+export declare function make(config: {
+    readonly description: string;
+    readonly jsonSchema: JsonSchema.JsonSchema;
+    readonly outputSchema?: JsonSchema.JsonSchema;
+    readonly execute: (params: unknown, context?: ToolExecuteContext) => Effect.Effect<unknown, ToolFailure>;
+    readonly toModelOutput?: (input: ToolModelOutputInput<unknown, unknown>) => ReadonlyArray<Tool.Content>;
+    readonly toStructuredOutput?: (output: unknown) => unknown;
+}): AnyExecutableTool;
+export declare function make(config: {
+    readonly description: string;
+    readonly jsonSchema: JsonSchema.JsonSchema;
+    readonly outputSchema?: JsonSchema.JsonSchema;
+    readonly execute?: undefined;
+    readonly toModelOutput?: (input: ToolModelOutputInput<unknown, unknown>) => ReadonlyArray<Tool.Content>;
+    readonly toStructuredOutput?: (output: unknown) => unknown;
+}): AnyTool;
+/**
+ * A record of named tools. The record key becomes the tool name on the wire.
+ */
+export type Tools = Record<string, AnyTool>;
+/**
+ * Convert a tools record into the `ToolDefinition[]` shape that
+ * `LLMRequest.tools` expects.
+ *
+ * Tool names come from the record keys, so the per-tool cached
+ * `_definition` is rebuilt with the correct name here. The JSON Schema body
+ * is reused.
+ */
+export declare const toDefinitions: (tools: Tools) => ReadonlyArray<ToolDefinitionClass>;
+export { ToolFailure };
+export * as Tool from "./tool.js";

package/dist/tool.js

@@ -0,0 +1,66 @@
+import { Effect, JsonSchema, Schema } from "effect";
+import { Tool } from "@opencode/schema/tool";
+import { ToolDefinition, ToolFailure, ToolOutput } from "./schema/index.js";
+export function make(config) {
+    if ("jsonSchema" in config) {
+        return {
+            description: config.description,
+            parameters: Schema.Unknown,
+            success: Schema.Unknown,
+            execute: config.execute,
+            toModelOutput: config.toModelOutput,
+            toStructuredOutput: config.toStructuredOutput,
+            _decode: Effect.succeed,
+            _encode: Effect.succeed,
+            _project: (parameters, id, output) => project(config.toModelOutput, config.toStructuredOutput, parameters, id, output),
+            _legacyResult: config.toModelOutput === undefined && config.toStructuredOutput === undefined,
+            _definition: new ToolDefinition({
+                name: "",
+                description: config.description,
+                inputSchema: config.jsonSchema,
+                outputSchema: config.outputSchema,
+            }),
+        };
+    }
+    return {
+        description: config.description,
+        parameters: config.parameters,
+        success: config.success,
+        execute: config.execute,
+        toModelOutput: config.toModelOutput,
+        toStructuredOutput: config.toStructuredOutput,
+        _decode: Schema.decodeUnknownEffect(config.parameters),
+        _encode: Schema.encodeEffect(config.success),
+        _project: (parameters, id, output) => project(config.toModelOutput, config.toStructuredOutput, parameters, id, output),
+        _legacyResult: false,
+        _definition: new ToolDefinition({
+            name: "",
+            description: config.description,
+            inputSchema: toJsonSchema(config.parameters),
+            outputSchema: toJsonSchema(config.success),
+        }),
+    };
+}
+/**
+ * Convert a tools record into the `ToolDefinition[]` shape that
+ * `LLMRequest.tools` expects.
+ *
+ * Tool names come from the record keys, so the per-tool cached
+ * `_definition` is rebuilt with the correct name here. The JSON Schema body
+ * is reused.
+ */
+export const toDefinitions = (tools) => Object.entries(tools).map(([name, item]) => new ToolDefinition({
+    name,
+    description: item._definition.description,
+    inputSchema: item._definition.inputSchema,
+    outputSchema: item._definition.outputSchema,
+}));
+const toJsonSchema = (schema) => {
+    const document = Schema.toJsonSchemaDocument(schema);
+    if (Object.keys(document.definitions).length === 0)
+        return document.schema;
+    return { ...document.schema, $defs: document.definitions };
+};
+const project = (toModelOutput, toStructuredOutput, parameters, id, output) => ToolOutput.make(toStructuredOutput?.(output) ?? output, toModelOutput?.({ id, parameters, output }) ?? (typeof output === "string" ? [{ type: "text", text: output }] : []));
+export { ToolFailure };
+export * as Tool from "./tool.js";

package/dist/utils/record.d.ts

@@ -0,0 +1,2 @@
+/** Plain-record narrowing. Excludes arrays so JSON object checks don't accept tuples as key/value bags. */
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;

package/dist/utils/record.js

@@ -0,0 +1,2 @@
+/** Plain-record narrowing. Excludes arrays so JSON object checks don't accept tuples as key/value bags. */
+export const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/utils/sanitize.d.ts

@@ -0,0 +1 @@
+export declare const sanitizeSurrogates: <T>(value: T) => T;

package/dist/utils/sanitize.js

@@ -0,0 +1,12 @@
+import { isRecord } from "./record.js";
+export const sanitizeSurrogates = (value) => {
+    if (typeof value === "string")
+        return value.toWellFormed();
+    if (Array.isArray(value))
+        return value.map(sanitizeSurrogates);
+    if (value instanceof Uint8Array || value instanceof Error)
+        return value;
+    if (isRecord(value))
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key.toWellFormed(), sanitizeSurrogates(entry)]));
+    return value;
+};

package/package.json

@@ -1,15 +1,48 @@
 {
+  "$schema": "https://json.schemastore.org/package.json",
+  "version": "2.0.1",
   "name": "@opencode/ai",
-  "version": "0.0.0-reserved",
-  "description": "OpenCode package bootstrap — not a functional release",
+  "type": "module",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/anomalyco/opencode.git"
+  "scripts": {
+    "setup:recording-env": "bun run script/setup-recording-env.ts",
+    "test": "bun test --timeout 30000 --only-failures",
+    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.types.json",
+    "build": "tsc -p tsconfig.build.json"
   },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public",
-    "tag": "reserved"
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./testing": {
+      "import": "./dist/testing.js",
+      "types": "./dist/testing.d.ts"
+    },
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  },
+  "devDependencies": {
+    "@clack/prompts": "1.0.0-alpha.1",
+    "@effect/platform-node": "4.0.0-rc.112",
+    "@opencode/http-recorder": "2.0.1",
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.4.0",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1",
+    "typescript": "5.8.2"
+  },
+  "dependencies": {
+    "@aws-sdk/credential-providers": "3.1057.0",
+    "@smithy/eventstream-codec": "4.2.14",
+    "@smithy/util-utf8": "4.2.2",
+    "@opencode/schema": "2.0.1",
+    "aws4fetch": "1.0.20",
+    "effect": "4.0.0-rc.112",
+    "google-auth-library": "10.5.0"
   }
-}
+}