@opencode-ai/ai 0.0.0-bootstrap.0 → 0.0.0-next-15617

package/dist/schema/options.d.ts

@@ -0,0 +1,143 @@
+import { Schema } from "effect";
+import { ModelID, ProviderID } from "./ids";
+import type { AnyRoute } from "../route/client";
+export declare const mergeJsonRecords: (...items: ReadonlyArray<Record<string, unknown> | undefined>) => Record<string, unknown> | undefined;
+export declare const ProviderOptions: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>;
+export type ProviderOptions = Schema.Schema.Type<typeof ProviderOptions>;
+export declare const mergeProviderOptions: (...items: ReadonlyArray<ProviderOptions | undefined>) => ProviderOptions | undefined;
+declare const HttpOptions_base: Schema.Class<HttpOptions, Schema.Struct<{
+    readonly body: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly query: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+}>, {}>;
+export declare class HttpOptions extends HttpOptions_base {
+}
+export declare namespace HttpOptions {
+    type Input = HttpOptions | ConstructorParameters<typeof HttpOptions>[0];
+    /** Normalize HTTP option input into the canonical `HttpOptions` class. */
+    const make: (input: Input) => HttpOptions;
+}
+export declare const mergeHttpOptions: (...items: ReadonlyArray<HttpOptions | undefined>) => HttpOptions | undefined;
+declare const GenerationOptions_base: Schema.Class<GenerationOptions, Schema.Struct<{
+    readonly maxTokens: Schema.optional<Schema.Number>;
+    readonly temperature: Schema.optional<Schema.Number>;
+    readonly topP: Schema.optional<Schema.Number>;
+    readonly topK: Schema.optional<Schema.Number>;
+    readonly frequencyPenalty: Schema.optional<Schema.Number>;
+    readonly presencePenalty: Schema.optional<Schema.Number>;
+    readonly seed: Schema.optional<Schema.Number>;
+    readonly stop: Schema.optional<Schema.$Array<Schema.String>>;
+}>, {}>;
+export declare class GenerationOptions extends GenerationOptions_base {
+}
+export declare namespace GenerationOptions {
+    type Input = GenerationOptions | ConstructorParameters<typeof GenerationOptions>[0];
+    /** Normalize generation option input into the canonical `GenerationOptions` class. */
+    const make: (input?: Input) => GenerationOptions;
+}
+export type GenerationOptionsFields = {
+    readonly maxTokens?: number;
+    readonly temperature?: number;
+    readonly topP?: number;
+    readonly topK?: number;
+    readonly frequencyPenalty?: number;
+    readonly presencePenalty?: number;
+    readonly seed?: number;
+    readonly stop?: ReadonlyArray<string>;
+};
+export type GenerationOptionsInput = GenerationOptions | GenerationOptionsFields;
+export declare const mergeGenerationOptions: (...items: ReadonlyArray<GenerationOptionsInput | undefined>) => GenerationOptions | undefined;
+declare const ModelLimits_base: Schema.Class<ModelLimits, Schema.Struct<{
+    readonly context: Schema.optional<Schema.Number>;
+    readonly output: Schema.optional<Schema.Number>;
+}>, {}>;
+export declare class ModelLimits extends ModelLimits_base {
+}
+export declare namespace ModelLimits {
+    type Input = ModelLimits | ConstructorParameters<typeof ModelLimits>[0];
+    /** Normalize model limit input into the canonical `ModelLimits` class. */
+    const make: (input: Input | undefined) => ModelLimits;
+}
+declare const ModelDefaults_base: Schema.Class<ModelDefaults, Schema.Struct<{
+    readonly limits: Schema.optional<typeof ModelLimits>;
+    readonly generation: Schema.optional<typeof GenerationOptions>;
+    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly http: Schema.optional<typeof HttpOptions>;
+}>, {}>;
+export declare class ModelDefaults extends ModelDefaults_base {
+}
+export declare namespace ModelDefaults {
+    type Input = ModelDefaults | {
+        readonly limits?: ModelLimits.Input;
+        readonly generation?: GenerationOptions.Input;
+        readonly providerOptions?: ProviderOptions;
+        readonly http?: HttpOptions.Input;
+    };
+    /** Normalize selected-model request defaults without applying precedence. */
+    const make: (input: Input) => ModelDefaults;
+}
+export declare const ModelToolSchemaCompatibility: Schema.Literals<readonly ["gemini", "moonshot"]>;
+export type ModelToolSchemaCompatibility = Schema.Schema.Type<typeof ModelToolSchemaCompatibility>;
+declare const ModelCompatibility_base: Schema.Class<ModelCompatibility, Schema.Struct<{
+    readonly toolSchema: Schema.optional<Schema.Literals<readonly ["gemini", "moonshot"]>>;
+}>, {}>;
+export declare class ModelCompatibility extends ModelCompatibility_base {
+}
+export declare namespace ModelCompatibility {
+    type Input = ModelCompatibility | ConstructorParameters<typeof ModelCompatibility>[0];
+    /** Normalize model/upstream compatibility metadata without projecting requests. */
+    const make: (input: Input) => ModelCompatibility;
+}
+export declare class Model {
+    readonly id: ModelID;
+    readonly provider: ProviderID;
+    readonly route: AnyRoute;
+    readonly defaults?: ModelDefaults;
+    readonly compatibility?: ModelCompatibility;
+    constructor(input: Model.ConstructorInput);
+    static make(input: Model.Input): Model;
+    static input(model: Model): Model.ConstructorInput;
+    static update(model: Model, patch: Partial<Model.Input>): Model;
+}
+export declare namespace Model {
+    type ConstructorInput = {
+        readonly id: ModelID;
+        readonly provider: ProviderID;
+        readonly route: AnyRoute;
+        readonly defaults?: ModelDefaults;
+        readonly compatibility?: ModelCompatibility;
+    };
+    type Input = Omit<ConstructorInput, "id" | "provider" | "defaults" | "compatibility"> & {
+        readonly id: string | ModelID;
+        readonly provider: string | ProviderID;
+        readonly defaults?: ModelDefaults.Input;
+        readonly compatibility?: ModelCompatibility.Input;
+    };
+}
+export type ModelInput = Model.Input;
+export declare const ModelSchema: Schema.declare<Model, Model>;
+declare const CacheHint_base: Schema.Class<CacheHint, Schema.Struct<{
+    readonly type: Schema.Literals<readonly ["ephemeral", "persistent"]>;
+    readonly ttlSeconds: Schema.optional<Schema.Number>;
+}>, {}>;
+export declare class CacheHint extends CacheHint_base {
+}
+export declare const CachePolicyObject: Schema.Struct<{
+    readonly tools: Schema.optional<Schema.Boolean>;
+    readonly system: Schema.optional<Schema.Boolean>;
+    readonly messages: Schema.optional<Schema.Union<readonly [Schema.Literal<"latest-user-message">, Schema.Literal<"latest-assistant">, Schema.Struct<{
+        readonly tail: Schema.Number;
+    }>]>>;
+    readonly ttlSeconds: Schema.optional<Schema.Number>;
+}>;
+export type CachePolicyObject = Schema.Schema.Type<typeof CachePolicyObject>;
+export declare const CachePolicy: Schema.Union<readonly [Schema.Literal<"auto">, Schema.Literal<"none">, Schema.Struct<{
+    readonly tools: Schema.optional<Schema.Boolean>;
+    readonly system: Schema.optional<Schema.Boolean>;
+    readonly messages: Schema.optional<Schema.Union<readonly [Schema.Literal<"latest-user-message">, Schema.Literal<"latest-assistant">, Schema.Struct<{
+        readonly tail: Schema.Number;
+    }>]>>;
+    readonly ttlSeconds: Schema.optional<Schema.Number>;
+}>]>;
+export type CachePolicy = Schema.Schema.Type<typeof CachePolicy>;
+export {};

package/dist/schema/options.js

@@ -0,0 +1,195 @@
+import { Schema } from "effect";
+import { JsonSchema, ModelID, ProviderID } from "./ids";
+import { isRecord } from "../utils/record";
+export const mergeJsonRecords = (...items) => {
+    const defined = items.filter((item) => item !== undefined);
+    if (defined.length === 0)
+        return undefined;
+    if (defined.length === 1 && Object.values(defined[0]).every((value) => value !== undefined))
+        return defined[0];
+    const result = {};
+    for (const item of defined) {
+        for (const [key, value] of Object.entries(item)) {
+            if (value === undefined)
+                continue;
+            result[key] = isRecord(result[key]) && isRecord(value) ? mergeJsonRecords(result[key], value) : value;
+        }
+    }
+    return Object.keys(result).length === 0 ? undefined : result;
+};
+const mergeStringRecords = (...items) => {
+    const defined = items.filter((item) => item !== undefined);
+    if (defined.length === 0)
+        return undefined;
+    if (defined.length === 1)
+        return defined[0];
+    const result = Object.fromEntries(defined.flatMap((item) => Object.entries(item).filter((entry) => entry[1] !== undefined)));
+    return Object.keys(result).length === 0 ? undefined : result;
+};
+export const ProviderOptions = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown));
+export const mergeProviderOptions = (...items) => {
+    const result = {};
+    for (const item of items) {
+        if (!item)
+            continue;
+        for (const [provider, options] of Object.entries(item)) {
+            const merged = mergeJsonRecords(result[provider], options);
+            if (merged)
+                result[provider] = merged;
+        }
+    }
+    return Object.keys(result).length === 0 ? undefined : result;
+};
+export class HttpOptions extends Schema.Class("LLM.HttpOptions")({
+    body: Schema.optional(JsonSchema),
+    headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    query: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+}) {
+}
+(function (HttpOptions) {
+    /** Normalize HTTP option input into the canonical `HttpOptions` class. */
+    HttpOptions.make = (input) => (input instanceof HttpOptions ? input : new HttpOptions(input));
+})(HttpOptions || (HttpOptions = {}));
+export const mergeHttpOptions = (...items) => {
+    const body = mergeJsonRecords(...items.map((item) => item?.body));
+    const headers = mergeStringRecords(...items.map((item) => item?.headers));
+    const query = mergeStringRecords(...items.map((item) => item?.query));
+    if (!body && !headers && !query)
+        return undefined;
+    return new HttpOptions({ body, headers, query });
+};
+export class GenerationOptions extends Schema.Class("LLM.GenerationOptions")({
+    maxTokens: Schema.optional(Schema.Number),
+    temperature: Schema.optional(Schema.Number),
+    topP: Schema.optional(Schema.Number),
+    topK: Schema.optional(Schema.Number),
+    frequencyPenalty: Schema.optional(Schema.Number),
+    presencePenalty: Schema.optional(Schema.Number),
+    seed: Schema.optional(Schema.Number),
+    stop: Schema.optional(Schema.Array(Schema.String)),
+}) {
+}
+(function (GenerationOptions) {
+    /** Normalize generation option input into the canonical `GenerationOptions` class. */
+    GenerationOptions.make = (input = {}) => (input instanceof GenerationOptions ? input : new GenerationOptions(input));
+})(GenerationOptions || (GenerationOptions = {}));
+const latestGeneration = (items, key) => items.findLast((item) => item?.[key] !== undefined)?.[key];
+export const mergeGenerationOptions = (...items) => {
+    const result = new GenerationOptions({
+        maxTokens: latestGeneration(items, "maxTokens"),
+        temperature: latestGeneration(items, "temperature"),
+        topP: latestGeneration(items, "topP"),
+        topK: latestGeneration(items, "topK"),
+        frequencyPenalty: latestGeneration(items, "frequencyPenalty"),
+        presencePenalty: latestGeneration(items, "presencePenalty"),
+        seed: latestGeneration(items, "seed"),
+        stop: latestGeneration(items, "stop"),
+    });
+    return Object.values(result).some((value) => value !== undefined) ? result : undefined;
+};
+export class ModelLimits extends Schema.Class("LLM.ModelLimits")({
+    context: Schema.optional(Schema.Number),
+    output: Schema.optional(Schema.Number),
+}) {
+}
+(function (ModelLimits) {
+    /** Normalize model limit input into the canonical `ModelLimits` class. */
+    ModelLimits.make = (input) => input instanceof ModelLimits ? input : new ModelLimits(input ?? {});
+})(ModelLimits || (ModelLimits = {}));
+export class ModelDefaults extends Schema.Class("LLM.ModelDefaults")({
+    limits: Schema.optional(ModelLimits),
+    generation: Schema.optional(GenerationOptions),
+    providerOptions: Schema.optional(ProviderOptions),
+    http: Schema.optional(HttpOptions),
+}) {
+}
+(function (ModelDefaults) {
+    /** Normalize selected-model request defaults without applying precedence. */
+    ModelDefaults.make = (input) => {
+        if (input instanceof ModelDefaults)
+            return input;
+        return new ModelDefaults({
+            limits: input.limits === undefined ? undefined : ModelLimits.make(input.limits),
+            generation: input.generation === undefined ? undefined : GenerationOptions.make(input.generation),
+            providerOptions: input.providerOptions,
+            http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        });
+    };
+})(ModelDefaults || (ModelDefaults = {}));
+export const ModelToolSchemaCompatibility = Schema.Literals(["gemini", "moonshot"]);
+export class ModelCompatibility extends Schema.Class("LLM.ModelCompatibility")({
+    toolSchema: Schema.optional(ModelToolSchemaCompatibility),
+}) {
+}
+(function (ModelCompatibility) {
+    /** Normalize model/upstream compatibility metadata without projecting requests. */
+    ModelCompatibility.make = (input) => (input instanceof ModelCompatibility ? input : new ModelCompatibility(input));
+})(ModelCompatibility || (ModelCompatibility = {}));
+export class Model {
+    id;
+    provider;
+    route;
+    defaults;
+    compatibility;
+    constructor(input) {
+        this.id = input.id;
+        this.provider = input.provider;
+        this.route = input.route;
+        this.defaults = input.defaults;
+        this.compatibility = input.compatibility;
+    }
+    static make(input) {
+        return new Model({
+            id: ModelID.make(input.id),
+            provider: ProviderID.make(input.provider),
+            route: input.route,
+            defaults: input.defaults === undefined ? undefined : ModelDefaults.make(input.defaults),
+            compatibility: input.compatibility === undefined ? undefined : ModelCompatibility.make(input.compatibility),
+        });
+    }
+    static input(model) {
+        return {
+            id: model.id,
+            provider: model.provider,
+            route: model.route,
+            defaults: model.defaults,
+            compatibility: model.compatibility,
+        };
+    }
+    static update(model, patch) {
+        if (Object.keys(patch).length === 0)
+            return model;
+        return Model.make({
+            ...Model.input(model),
+            ...patch,
+        });
+    }
+}
+export const ModelSchema = Schema.declare((value) => value instanceof Model, { expected: "LLM.Model" });
+export class CacheHint extends Schema.Class("LLM.CacheHint")({
+    type: Schema.Literals(["ephemeral", "persistent"]),
+    ttlSeconds: Schema.optional(Schema.Number),
+}) {
+}
+// Auto-placement policy for prompt caching. The protocol-neutral lowering step
+// reads this and injects `CacheHint`s at the configured boundaries; the
+// per-protocol body builders then translate those hints into wire markers as
+// usual. `"auto"` is the recommended default for agent loops — it places one
+// breakpoint at the last tool definition, one at the last system part, and one
+// at the latest user message. The combination of provider invalidation
+// hierarchy (tools → system → messages) and Anthropic/Bedrock's 20-block
+// lookback means three trailing breakpoints reliably cover the static prefix.
+//
+// Pass `"none"` to opt out entirely (the legacy behavior). Pass the granular
+// object form to override individual choices.
+export const CachePolicyObject = Schema.Struct({
+    tools: Schema.optional(Schema.Boolean),
+    system: Schema.optional(Schema.Boolean),
+    messages: Schema.optional(Schema.Union([
+        Schema.Literal("latest-user-message"),
+        Schema.Literal("latest-assistant"),
+        Schema.Struct({ tail: Schema.Number }),
+    ])),
+    ttlSeconds: Schema.optional(Schema.Number),
+});
+export const CachePolicy = Schema.Union([Schema.Literal("auto"), Schema.Literal("none"), CachePolicyObject]);

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";
+import { type Tools } from "./tool";
+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,35 @@
+import { Effect } from "effect";
+import { LLMEvent, ToolFailure, ToolOutput, ToolResultValue, } from "./schema";
+import {} from "./tool";
+/** Execute one canonical tool call without owning provider IO or continuation. */
+export const dispatch = (tools, call) => {
+    const tool = tools[call.name];
+    if (!tool)
+        return Effect.succeed(result(call, { type: "error", value: `Unknown tool: ${call.name}` }));
+    if (!tool.execute)
+        return Effect.succeed(result(call, { type: "error", value: `Tool has no execute handler: ${call.name}` }));
+    return decodeAndExecute(tool, call).pipe(Effect.map((value) => result(call, value)), Effect.catchTag("LLM.ToolFailure", (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 }).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, message: String(settlement.result.value), error }),
+                LLMEvent.toolResult({ id: call.id, name: call.name, result: settlement.result }),
+            ]
+            : [LLMEvent.toolResult({ id: call.id, name: call.name, result: settlement.result, output: settlement.output })],
+    };
+};
+export const ToolRuntime = { dispatch };

package/dist/tool.d.ts

@@ -0,0 +1,134 @@
+import { Effect, JsonSchema, Schema } from "effect";
+import type { ToolCallPart, ToolContent, ToolDefinition as ToolDefinitionClass, ToolOutput as ToolOutputType } from "./schema";
+import { ToolFailure } from "./schema";
+/**
+ * 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"];
+}
+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 callID: 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<ToolContent>;
+/**
+ * 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>, callID: 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<ToolContent>;
+    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<ToolContent>;
+    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";

package/dist/tool.js

@@ -0,0 +1,66 @@
+import { Effect, JsonSchema, Schema } from "effect";
+import { ToolDefinition, ToolFailure, ToolOutput } from "./schema";
+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, callID, output) => project(config.toModelOutput, config.toStructuredOutput, parameters, callID, 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, callID, output) => project(config.toModelOutput, config.toStructuredOutput, parameters, callID, 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, callID, output) => ToolOutput.make(toStructuredOutput?.(output) ?? output, toModelOutput?.({ callID, parameters, output }) ??
+    (typeof output === "string" ? [{ type: "text", text: output }] : []));
+export { ToolFailure };
+export * as Tool from "./tool";

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/package.json

@@ -1,16 +1,43 @@
 {
+  "$schema": "https://json.schemastore.org/package.json",
+  "version": "0.0.0-next-15617",
   "name": "@opencode-ai/ai",
-  "version": "0.0.0-bootstrap.0",
-  "description": "Bootstrap package for @opencode-ai/ai",
   "type": "module",
   "license": "MIT",
-  "exports": "./index.js",
+  "scripts": {
+    "setup:recording-env": "bun run script/setup-recording-env.ts",
+    "test": "bun test --timeout 30000 --only-failures",
+    "typecheck": "tsgo --noEmit",
+    "build": "tsc -p tsconfig.build.json"
+  },
   "files": [
-    "index.js",
-    "README.md"
+    "dist"
   ],
-  "publishConfig": {
-    "access": "public",
-    "provenance": false
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  },
+  "devDependencies": {
+    "@clack/prompts": "1.0.0-alpha.1",
+    "@effect/platform-node": "4.0.0-beta.83",
+    "@opencode-ai/http-recorder": "0.0.0-next-15617",
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.3.13",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1",
+    "typescript": "5.8.2"
+  },
+  "dependencies": {
+    "@smithy/eventstream-codec": "4.2.14",
+    "@smithy/util-utf8": "4.2.2",
+    "@opencode-ai/schema": "0.0.0-next-15617",
+    "aws4fetch": "1.0.20",
+    "effect": "4.0.0-beta.83",
+    "google-auth-library": "10.5.0"
   }
-}
+}

package/index.js

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