@opencode-ai/ai 0.0.0-dev-18409 → 0.0.0-dev-18412

package/dist/schema/errors.d.ts

@@ -2,18 +2,12 @@ import { Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
 export declare const ProviderFailureClassification: Schema.Literals<readonly ["context-overflow", "payload-too-large"]>;
 export type ProviderFailureClassification = typeof ProviderFailureClassification.Type;
-declare const HttpRequestDetails_base: Schema.Class<HttpRequestDetails, Schema.Struct<{
-    readonly method: Schema.String;
+declare const HttpContext_base: Schema.Class<HttpContext, Schema.Struct<{
     readonly url: Schema.String;
+    readonly status: Schema.Int;
     readonly headers: Schema.$Record<Schema.String, Schema.String>;
 }>, {}>;
-export declare class HttpRequestDetails extends HttpRequestDetails_base {
-}
-declare const HttpResponseDetails_base: Schema.Class<HttpResponseDetails, Schema.Struct<{
-    readonly status: Schema.Number;
-    readonly headers: Schema.$Record<Schema.String, Schema.String>;
-}>, {}>;
-export declare class HttpResponseDetails extends HttpResponseDetails_base {
+export declare class HttpContext extends HttpContext_base {
 }
 declare const HttpRateLimitDetails_base: Schema.Class<HttpRateLimitDetails, Schema.Struct<{
     readonly retryAfterMs: Schema.optional<Schema.Number>;
@@ -23,126 +17,115 @@ declare const HttpRateLimitDetails_base: Schema.Class<HttpRateLimitDetails, Sche
 }>, {}>;
 export declare class HttpRateLimitDetails extends HttpRateLimitDetails_base {
 }
-declare const HttpContext_base: Schema.Class<HttpContext, Schema.Struct<{
-    readonly request: typeof HttpRequestDetails;
-    readonly response: Schema.optional<typeof HttpResponseDetails>;
-    readonly body: Schema.optional<Schema.String>;
-    readonly bodyTruncated: Schema.optional<Schema.Boolean>;
-    readonly rateLimit: Schema.optional<typeof HttpRateLimitDetails>;
-}>, {}>;
-export declare class HttpContext extends HttpContext_base {
-}
-declare const InvalidRequestReason_base: Schema.Class<InvalidRequestReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"InvalidRequest">;
-    readonly message: Schema.String;
+declare const InvalidRequestError_base: Schema.Class<InvalidRequestError, Schema.TaggedStruct<"InvalidRequest", {
     readonly parameter: Schema.optional<Schema.String>;
     readonly classification: Schema.optional<Schema.Literals<readonly ["context-overflow", "payload-too-large"]>>;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly message: Schema.String;
+    readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class InvalidRequestReason extends InvalidRequestReason_base {
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidRequestError extends InvalidRequestError_base {
 }
-declare const NoRouteReason_base: Schema.Class<NoRouteReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"NoRoute">;
+declare const NoRouteError_base: Schema.Class<NoRouteError, Schema.TaggedStruct<"NoRoute", {
     readonly route: Schema.String;
     readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
     readonly model: Schema.brand<Schema.String, "AI.ModelID">;
-}>, {}>;
-export declare class NoRouteReason extends NoRouteReason_base {
-    get message(): string;
-}
-declare const AuthenticationReason_base: Schema.Class<AuthenticationReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"Authentication">;
     readonly message: Schema.String;
-    readonly kind: Schema.Literals<readonly ["missing", "invalid", "expired", "insufficient-permissions", "unknown"]>;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class AuthenticationReason extends AuthenticationReason_base {
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class NoRouteError extends NoRouteError_base {
 }
-declare const RateLimitReason_base: Schema.Class<RateLimitReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"RateLimit">;
+declare const AuthenticationError_base: Schema.Class<AuthenticationError, Schema.TaggedStruct<"Authentication", {
+    readonly kind: Schema.Literals<readonly ["missing", "invalid", "expired", "insufficient-permissions", "unknown"]>;
     readonly message: Schema.String;
-    readonly retryAfterMs: Schema.optional<Schema.Number>;
-    readonly rateLimit: Schema.optional<typeof HttpRateLimitDetails>;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class RateLimitReason extends RateLimitReason_base {
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class AuthenticationError extends AuthenticationError_base {
 }
-declare const QuotaExceededReason_base: Schema.Class<QuotaExceededReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"QuotaExceeded">;
+declare const RateLimitError_base: Schema.Class<RateLimitError, Schema.TaggedStruct<"RateLimit", {
+    readonly retryAfterMs: Schema.optional<Schema.Number>;
+    readonly rateLimit: Schema.optional<typeof HttpRateLimitDetails>;
     readonly message: Schema.String;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class QuotaExceededReason extends QuotaExceededReason_base {
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class RateLimitError extends RateLimitError_base {
 }
-declare const ContentPolicyReason_base: Schema.Class<ContentPolicyReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"ContentPolicy">;
-    readonly message: Schema.String;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
-    readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class ContentPolicyReason extends ContentPolicyReason_base {
+declare const QuotaExceededError_base: Schema.Class<QuotaExceededError, Schema.TaggedStruct<"QuotaExceeded", {
+    message: Schema.String;
+    body: Schema.optional<Schema.String>;
+    http: Schema.optional<typeof HttpContext>;
+    cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class QuotaExceededError extends QuotaExceededError_base {
 }
-declare const ProviderInternalReason_base: Schema.Class<ProviderInternalReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"ProviderInternal">;
-    readonly message: Schema.String;
-    readonly status: Schema.optional<Schema.Number>;
+declare const ContentPolicyError_base: Schema.Class<ContentPolicyError, Schema.TaggedStruct<"ContentPolicy", {
+    message: Schema.String;
+    body: Schema.optional<Schema.String>;
+    http: Schema.optional<typeof HttpContext>;
+    cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ContentPolicyError extends ContentPolicyError_base {
+}
+declare const ProviderInternalError_base: Schema.Class<ProviderInternalError, Schema.TaggedStruct<"ProviderInternal", {
     readonly retryAfterMs: Schema.optional<Schema.Number>;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly message: Schema.String;
+    readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class ProviderInternalReason extends ProviderInternalReason_base {
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProviderInternalError extends ProviderInternalError_base {
 }
 export declare const TransportType: Schema.Literals<readonly ["http", "websocket"]>;
 export type TransportType = typeof TransportType.Type;
 export declare const TransportOperation: Schema.Literals<readonly ["request", "read", "write"]>;
 export type TransportOperation = typeof TransportOperation.Type;
-declare const TransportReason_base: Schema.Class<TransportReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"Transport">;
-    readonly message: Schema.String;
+declare const TransportError_base: Schema.Class<TransportError, Schema.TaggedStruct<"Transport", {
     readonly transport: Schema.Literals<readonly ["http", "websocket"]>;
     readonly operation: Schema.Literals<readonly ["request", "read", "write"]>;
     readonly code: Schema.optional<Schema.String>;
     readonly url: Schema.optional<Schema.String>;
-    readonly http: Schema.optional<typeof HttpContext>;
     readonly phase: Schema.optional<Schema.Literals<readonly ["prepare", "queue", "connect", "send", "receive", "decode", "complete", "fallback", "close"]>>;
     readonly delivery: Schema.optional<Schema.Literals<readonly ["not-sent", "rejected", "ambiguous", "accepted"]>>;
     readonly recovery: Schema.optional<Schema.Literals<readonly ["retry-connect", "retry-full", "rotate-and-retry-full", "fallback-http", "fail"]>>;
-}>, {}>;
-export declare class TransportReason extends TransportReason_base {
-}
-declare const InvalidProviderOutputReason_base: Schema.Class<InvalidProviderOutputReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"InvalidProviderOutput">;
     readonly message: Schema.String;
+    readonly body: Schema.optional<Schema.String>;
+    readonly http: Schema.optional<typeof HttpContext>;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class TransportError extends TransportError_base {
+}
+declare const InvalidProviderOutputError_base: Schema.Class<InvalidProviderOutputError, Schema.TaggedStruct<"InvalidProviderOutput", {
     readonly classification: Schema.optional<Schema.Literals<readonly ["incomplete-stream"]>>;
     readonly route: Schema.optional<Schema.String>;
-    readonly raw: Schema.optional<Schema.String>;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
-}>, {}>;
-export declare class InvalidProviderOutputReason extends InvalidProviderOutputReason_base {
-}
-declare const UnknownProviderReason_base: Schema.Class<UnknownProviderReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"UnknownProvider">;
     readonly message: Schema.String;
-    readonly status: Schema.optional<Schema.Number>;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class UnknownProviderReason extends UnknownProviderReason_base {
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidProviderOutputError extends InvalidProviderOutputError_base {
 }
-export declare const AIErrorReason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestReason, typeof NoRouteReason, typeof AuthenticationReason, typeof RateLimitReason, typeof QuotaExceededReason, typeof ContentPolicyReason, typeof ProviderInternalReason, typeof TransportReason, typeof InvalidProviderOutputReason, typeof UnknownProviderReason]>;
+declare const UnknownProviderError_base: Schema.Class<UnknownProviderError, Schema.TaggedStruct<"UnknownProvider", {
+    message: Schema.String;
+    body: Schema.optional<Schema.String>;
+    http: Schema.optional<typeof HttpContext>;
+    cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class UnknownProviderError extends UnknownProviderError_base {
+}
+export declare const AIErrorReason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestError, typeof NoRouteError, typeof AuthenticationError, typeof RateLimitError, typeof QuotaExceededError, typeof ContentPolicyError, typeof ProviderInternalError, typeof TransportError, typeof InvalidProviderOutputError, typeof UnknownProviderError]>;
 export type AIErrorReason = Schema.Schema.Type<typeof AIErrorReason>;
 declare const AIError_base: Schema.Class<AIError, Schema.TaggedStruct<"AI.Error", {
-    readonly module: Schema.String;
-    readonly method: Schema.String;
-    readonly reason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestReason, typeof NoRouteReason, typeof AuthenticationReason, typeof RateLimitReason, typeof QuotaExceededReason, typeof ContentPolicyReason, typeof ProviderInternalReason, typeof TransportReason, typeof InvalidProviderOutputReason, typeof UnknownProviderReason]>;
-    readonly body: Schema.optional<Schema.String>;
+    readonly reason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestError, typeof NoRouteError, typeof AuthenticationError, typeof RateLimitError, typeof QuotaExceededError, typeof ContentPolicyError, typeof ProviderInternalError, typeof TransportError, typeof InvalidProviderOutputError, typeof UnknownProviderError]>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AIError extends AIError_base {
-    readonly cause: InvalidRequestReason | NoRouteReason | AuthenticationReason | RateLimitReason | QuotaExceededReason | ContentPolicyReason | ProviderInternalReason | TransportReason | InvalidProviderOutputReason | UnknownProviderReason;
+    readonly cause: InvalidRequestError | NoRouteError | AuthenticationError | RateLimitError | QuotaExceededError | ContentPolicyError | ProviderInternalError | TransportError | InvalidProviderOutputError | UnknownProviderError;
     get message(): string;
 }
 /**

package/dist/schema/errors.js

@@ -1,16 +1,10 @@
 import { Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
 import { ModelID, ProviderID, RouteID } from "./ids.js";
-import { ProviderMetadata } from "./messages.js";
 export const ProviderFailureClassification = Schema.Literals(["context-overflow", "payload-too-large"]);
-export class HttpRequestDetails extends Schema.Class("AI.HttpRequestDetails")({
-    method: Schema.String,
+export class HttpContext extends Schema.Class("AI.HttpContext")({
     url: Schema.String,
-    headers: Schema.Record(Schema.String, Schema.String),
-}) {
-}
-export class HttpResponseDetails extends Schema.Class("AI.HttpResponseDetails")({
-    status: Schema.Number,
+    status: Schema.Int.check(Schema.isBetween({ minimum: 100, maximum: 599 })),
     headers: Schema.Record(Schema.String, Schema.String),
 }) {
 }
@@ -21,128 +15,85 @@ export class HttpRateLimitDetails extends Schema.Class("AI.HttpRateLimitDetails"
     reset: Schema.optional(Schema.Record(Schema.String, Schema.String)),
 }) {
 }
-export class HttpContext extends Schema.Class("AI.HttpContext")({
-    request: HttpRequestDetails,
-    response: Schema.optional(HttpResponseDetails),
-    body: Schema.optional(Schema.String),
-    bodyTruncated: Schema.optional(Schema.Boolean),
-    rateLimit: Schema.optional(HttpRateLimitDetails),
-}) {
-}
-export class InvalidRequestReason extends Schema.Class("AI.Error.InvalidRequest")({
-    _tag: Schema.tag("InvalidRequest"),
+const ReasonFields = {
     message: Schema.String,
+    // Preserve the complete original response or triggering event before decoding narrows it.
+    body: Schema.optional(Schema.String),
+    http: Schema.optional(HttpContext),
+    cause: Schema.optional(Schema.Defect({ includeStack: true })),
+};
+export class InvalidRequestError extends Schema.TaggedError("AI.Error.InvalidRequest")("InvalidRequest", {
+    ...ReasonFields,
     parameter: Schema.optional(Schema.String),
     classification: Schema.optional(ProviderFailureClassification),
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
 }) {
 }
-export class NoRouteReason extends Schema.Class("AI.Error.NoRoute")({
-    _tag: Schema.tag("NoRoute"),
+export class NoRouteError extends Schema.TaggedError("AI.Error.NoRoute")("NoRoute", {
+    ...ReasonFields,
     route: RouteID,
     provider: ProviderID,
     model: ModelID,
 }) {
-    get message() {
-        return `No AI route for ${this.provider}/${this.model} using ${this.route}`;
-    }
 }
-export class AuthenticationReason extends Schema.Class("AI.Error.Authentication")({
-    _tag: Schema.tag("Authentication"),
-    message: Schema.String,
+export class AuthenticationError extends Schema.TaggedError("AI.Error.Authentication")("Authentication", {
+    ...ReasonFields,
     kind: Schema.Literals(["missing", "invalid", "expired", "insufficient-permissions", "unknown"]),
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
 }) {
 }
-export class RateLimitReason extends Schema.Class("AI.Error.RateLimit")({
-    _tag: Schema.tag("RateLimit"),
-    message: Schema.String,
+export class RateLimitError extends Schema.TaggedError("AI.Error.RateLimit")("RateLimit", {
+    ...ReasonFields,
     retryAfterMs: Schema.optional(Schema.Number),
     rateLimit: Schema.optional(HttpRateLimitDetails),
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
 }) {
 }
-export class QuotaExceededReason extends Schema.Class("AI.Error.QuotaExceeded")({
-    _tag: Schema.tag("QuotaExceeded"),
-    message: Schema.String,
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
-}) {
+export class QuotaExceededError extends Schema.TaggedError("AI.Error.QuotaExceeded")("QuotaExceeded", ReasonFields) {
 }
-export class ContentPolicyReason extends Schema.Class("AI.Error.ContentPolicy")({
-    _tag: Schema.tag("ContentPolicy"),
-    message: Schema.String,
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
-}) {
+export class ContentPolicyError extends Schema.TaggedError("AI.Error.ContentPolicy")("ContentPolicy", ReasonFields) {
 }
-export class ProviderInternalReason extends Schema.Class("AI.Error.ProviderInternal")({
-    _tag: Schema.tag("ProviderInternal"),
-    message: Schema.String,
-    status: Schema.optional(Schema.Number),
+export class ProviderInternalError extends Schema.TaggedError("AI.Error.ProviderInternal")("ProviderInternal", {
+    ...ReasonFields,
     retryAfterMs: Schema.optional(Schema.Number),
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
 }) {
 }
 export const TransportType = Schema.Literals(["http", "websocket"]);
 export const TransportOperation = Schema.Literals(["request", "read", "write"]);
-export class TransportReason extends Schema.Class("AI.Error.Transport")({
-    _tag: Schema.tag("Transport"),
-    message: Schema.String,
+export class TransportError extends Schema.TaggedError("AI.Error.Transport")("Transport", {
+    ...ReasonFields,
     transport: TransportType,
     operation: TransportOperation,
     code: Schema.optional(Schema.String),
     url: Schema.optional(Schema.String),
-    http: Schema.optional(HttpContext),
     phase: Schema.optional(Schema.Literals(["prepare", "queue", "connect", "send", "receive", "decode", "complete", "fallback", "close"])),
     delivery: Schema.optional(Schema.Literals(["not-sent", "rejected", "ambiguous", "accepted"])),
     recovery: Schema.optional(Schema.Literals(["retry-connect", "retry-full", "rotate-and-retry-full", "fallback-http", "fail"])),
 }) {
 }
-export class InvalidProviderOutputReason extends Schema.Class("AI.Error.InvalidProviderOutput")({
-    _tag: Schema.tag("InvalidProviderOutput"),
-    message: Schema.String,
+export class InvalidProviderOutputError extends Schema.TaggedError("AI.Error.InvalidProviderOutput")("InvalidProviderOutput", {
+    ...ReasonFields,
     classification: Schema.optional(Schema.Literals(["incomplete-stream"])),
     route: Schema.optional(Schema.String),
-    raw: Schema.optional(Schema.String),
-    providerMetadata: Schema.optional(ProviderMetadata),
 }) {
 }
-export class UnknownProviderReason extends Schema.Class("AI.Error.UnknownProvider")({
-    _tag: Schema.tag("UnknownProvider"),
-    message: Schema.String,
-    status: Schema.optional(Schema.Number),
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
-}) {
+export class UnknownProviderError extends Schema.TaggedError("AI.Error.UnknownProvider")("UnknownProvider", ReasonFields) {
 }
 export const AIErrorReason = Schema.Union([
-    InvalidRequestReason,
-    NoRouteReason,
-    AuthenticationReason,
-    RateLimitReason,
-    QuotaExceededReason,
-    ContentPolicyReason,
-    ProviderInternalReason,
-    TransportReason,
-    InvalidProviderOutputReason,
-    UnknownProviderReason,
+    InvalidRequestError,
+    NoRouteError,
+    AuthenticationError,
+    RateLimitError,
+    QuotaExceededError,
+    ContentPolicyError,
+    ProviderInternalError,
+    TransportError,
+    InvalidProviderOutputError,
+    UnknownProviderError,
 ]).pipe(Schema.toTaggedUnion("_tag"));
 export class AIError extends Schema.TaggedError()("AI.Error", {
-    module: Schema.String,
-    method: Schema.String,
     reason: AIErrorReason,
-    // Raw provider payload as a string, so classified failures never lose the
-    // original error detail even when the pretty message is a summary.
-    body: Schema.optional(Schema.String),
 }) {
     cause = this.reason;
     get message() {
-        return `${this.module}.${this.method}: ${this.reason.message}`;
+        return this.reason.message;
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-18409",
+  "version": "0.0.0-dev-18412",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.111",
-    "@opencode-ai/http-recorder": "0.0.0-dev-18409",
+    "@opencode-ai/http-recorder": "0.0.0-dev-18412",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -39,7 +39,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-dev-18409",
+    "@opencode-ai/schema": "0.0.0-dev-18412",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.111",
     "google-auth-library": "10.5.0"