@opencode/codemode 0.0.0-dev-20782 → 0.0.0-dev-20784

package/dist/openapi/index.js

@@ -1,4 +1,4 @@
-import { HttpClient } from "effect/unstable/http";
+import { HttpClient } from "effect/http";
 import { make } from "../tool.js";
 import { invoke } from "./runtime.js";
 import { componentDefinitions, hasDirectionalSchemas, inputSchema, isRecord, methods, nonEmptyString, operationInput, operationOutput, operationPath, operationSecurityRequirements, securityRequirements, securitySchemes, specServerUrl, validateBaseUrl, } from "./spec.js";

package/dist/openapi/runtime.d.ts

@@ -1,4 +1,4 @@
 import { Effect } from "effect";
-import { HttpClient } from "effect/unstable/http";
+import { HttpClient } from "effect/http";
 import type { Plan } from "./types.js";
 export declare const invoke: (plan: Plan, input: unknown) => Effect.Effect<unknown, unknown, HttpClient.HttpClient>;

package/dist/openapi/runtime.js

@@ -1,5 +1,5 @@
 import { Effect, Option, Schema, Stream } from "effect";
-import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";
 import { ToolError, toolError } from "../tool-error.js";
 import { isRecord, own } from "./spec.js";
 const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));

package/dist/openapi/types.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { HttpClient } from "effect/unstable/http";
+import { HttpClient } from "effect/http";
 import type { Tool, JsonSchema } from "../tool.js";
 /** A parsed OpenAPI 3.x document. YAML must be parsed by the ctx. */
 export type Document = Record<string, unknown>;

package/dist/openapi/types.js

@@ -1,2 +1,2 @@
 import { Effect } from "effect";
-import { HttpClient } from "effect/unstable/http";
+import { HttpClient } from "effect/http";

package/dist/tool-schema.js

@@ -3,10 +3,23 @@ const isEffectSchema = (schema) => Schema.isSchema(schema);
 const renderLiteral = (value) => JSON.stringify(value) ?? "unknown";
 export const identifierSegment = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 const renderKey = (name) => (identifierSegment.test(name) ? name : JSON.stringify(name));
+const definitionName = (ref) => {
+    const tokens = JsonPointer.parseUriFragment(ref);
+    return tokens?.length === 2 && (tokens[0] === "$defs" || tokens[0] === "definitions") ? tokens[1] : undefined;
+};
+// Effect encodes an unchecked `number` as `number | "Infinity" | "-Infinity" | "NaN"`, and older generators emit one
+// singleton enum per value. Rendering them as plain `number` only narrows what the model is told to send.
 const effectNumberSentinel = (schema) => schema.type === "string" &&
     Array.isArray(schema.enum) &&
-    schema.enum.length === 1 &&
-    (schema.enum[0] === "NaN" || schema.enum[0] === "Infinity" || schema.enum[0] === "-Infinity");
+    schema.enum.length > 0 &&
+    schema.enum.every((value) => value === "NaN" || value === "Infinity" || value === "-Infinity");
+// Effect emits `{ not: { type: "null" } }` only for a struct with no properties or index signatures. With nothing but
+// annotations beside it, it is TypeScript's `{}`. Mirrors `emptyInputJsonSchema` in `@opencode/ai`, which this
+// standalone package cannot import.
+const annotationKeywords = new Set(["title", "description", "default", "examples", "readOnly", "writeOnly"]);
+const isEffectEmptyStruct = (schema) => schema.not?.type === "null" &&
+    Object.keys(schema.not).length === 1 &&
+    Object.keys(schema).every((key) => key === "not" || annotationKeywords.has(key));
 const intersection = (members) => {
     const concrete = members.filter((member) => member !== "unknown");
     if (concrete.length === 0)
@@ -21,8 +34,7 @@ const hasUnresolvedRef = (schema, definitions, seen = new Set(), visited = new S
         return false;
     const nextVisited = new Set([...visited, schema]);
     if (schema.$ref !== undefined) {
-        const segment = schema.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)?.[1];
-        const name = segment === undefined ? undefined : JsonPointer.unescapeToken(segment);
+        const name = definitionName(schema.$ref);
         if (name === undefined || definitions[name] === undefined || seen.has(name))
             return true;
         if (hasUnresolvedRef(definitions[name], definitions, new Set([...seen, name]), nextVisited))
@@ -124,8 +136,7 @@ const renderSchema = (schema, ctx, depth = 0, seen = new Set()) => {
         ? ctx
         : { ...ctx, definitions: { ...ctx.definitions, ...(schema.definitions ?? {}), ...(schema.$defs ?? {}) } };
     if (schema.$ref) {
-        const segment = schema.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)?.[1];
-        const name = segment === undefined ? undefined : JsonPointer.unescapeToken(segment);
+        const name = definitionName(schema.$ref);
         if (!name || !nested.definitions[name] || seen.has(name))
             return "unknown";
         return intersection([
@@ -142,6 +153,7 @@ const renderSchema = (schema, ctx, depth = 0, seen = new Set()) => {
         if (alternatives.some((item) => item.type === "number") &&
             alternatives.every((item) => item.type === "number" || effectNumberSentinel(item)))
             return "number";
+        // Older Effect releases emitted this pair for an empty struct, and raw schemas from their generators still can.
         if (alternatives.length === 2 &&
             alternatives[0]?.type === "object" &&
             alternatives[0].properties === undefined &&
@@ -196,13 +208,16 @@ const renderSchema = (schema, ctx, depth = 0, seen = new Set()) => {
             lines.push(`${pad}[key: string]: ${indexType},`);
         return `{\n${lines.join("\n")}\n${"  ".repeat(depth)}}`;
     }
+    if (isEffectEmptyStruct(schema))
+        return "{}";
     return "unknown";
 };
 export const toTypeScript = (schema, decoded = false, pretty = false) => {
     try {
-        const visible = decoded ? Schema.toType(schema) : schema;
-        const document = Schema.toJsonSchemaDocument(visible);
-        return renderSchema(document.schema, { definitions: document.definitions ?? {}, pretty });
+        const document = Schema.toJsonSchemaDocument(decoded ? Schema.toType(schema) : schema, {
+            onExcessProperty: "error",
+        });
+        return renderSchema(document.schema, { definitions: document.definitions, pretty });
     }
     catch {
         return "unknown";
@@ -219,17 +234,15 @@ export const jsonSchemaToTypeScript = (schema, pretty = false) => {
 export const inputProperties = (tool) => {
     try {
         const document = isEffectSchema(tool.input)
-            ? Schema.toJsonSchemaDocument(tool.input)
+            ? Schema.toJsonSchemaDocument(tool.input, { onExcessProperty: "error" })
             : {
                 schema: tool.input,
                 definitions: { ...(tool.input.definitions ?? {}), ...(tool.input.$defs ?? {}) },
             };
-        const definitions = document.definitions ?? {};
         let schema = document.schema;
         if (schema.$ref !== undefined) {
-            const segment = schema.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)?.[1];
-            const name = segment === undefined ? undefined : JsonPointer.unescapeToken(segment);
-            const resolved = name === undefined ? undefined : definitions[name];
+            const name = definitionName(schema.$ref);
+            const resolved = name === undefined ? undefined : document.definitions[name];
             if (resolved === undefined)
                 return [];
             schema = resolved;
@@ -246,10 +259,11 @@ export const inputProperties = (tool) => {
     }
 };
 export const inputTypeScript = (tool, pretty = false) => isEffectSchema(tool.input) ? toTypeScript(tool.input, false, pretty) : jsonSchemaToTypeScript(tool.input, pretty);
-// Empty object schemas render as `{}` in compact form; anything with properties,
-// an index signature, or union members renders differently, so equality is a
-// conservative emptiness test for both Effect and JSON Schema inputs.
-export const isEmptyInput = (tool) => inputTypeScript(tool) === "{}";
+// Effect inputs are empty only when their encoded root is Effect's empty-struct marker, which records and checked
+// structs never are. Raw JSON Schema inputs keep the `{}` rendering check, which treats `{ type: "object" }` as empty.
+export const isEmptyInput = (tool) => isEffectSchema(tool.input)
+    ? isEffectEmptyStruct(Schema.toJsonSchemaDocument(tool.input, { referencePolicy: () => undefined }).schema)
+    : inputTypeScript(tool) === "{}";
 export const outputTypeScript = (tool, pretty = false) => tool.output === undefined
     ? "void"
     : isEffectSchema(tool.output)

package/dist/tool.d.ts

@@ -12,6 +12,7 @@ export type JsonSchema = {
     readonly anyOf?: ReadonlyArray<JsonSchema>;
     readonly oneOf?: ReadonlyArray<JsonSchema>;
     readonly allOf?: ReadonlyArray<JsonSchema>;
+    readonly not?: JsonSchema;
     readonly properties?: Readonly<Record<string, JsonSchema>>;
     readonly required?: ReadonlyArray<string>;
     readonly items?: JsonSchema;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "0.0.0-dev-20782",
+  "version": "0.0.0-dev-20784",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "acorn": "8.15.0",
-    "effect": "4.0.0-rc.112"
+    "effect": "4.0.0-rc.118"
   },
   "devDependencies": {
     "@tsconfig/bun": "1.0.9",