effect 4.0.0-beta.6 → 4.0.0-beta.62

package/src/unstable/ai/ResponseIdTracker.ts

@@ -0,0 +1,95 @@
+/**
+ * @since 4.0.0
+ */
+import * as Context from "../../Context.ts"
+import * as Effect from "../../Effect.ts"
+import * as Option from "../../Option.ts"
+import * as Prompt from "./Prompt.ts"
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface PrepareResult {
+  readonly previousResponseId: string
+  readonly prompt: Prompt.Prompt
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface Service {
+  clearUnsafe(): void
+  markParts(parts: ReadonlyArray<object>, responseId: string): void
+  prepareUnsafe(prompt: Prompt.Prompt): Option.Option<PrepareResult>
+}
+
+/**
+ * @since 4.0.0
+ * @category Services
+ */
+export class ResponseIdTracker extends Context.Service<ResponseIdTracker, Service>()("effect/ai/ResponseIdTracker") {}
+
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export const make: Effect.Effect<Service> = Effect.sync(() => {
+  const sentParts = new Map<object, string>()
+
+  const none = () => {
+    sentParts.clear()
+    return Option.none<PrepareResult>()
+  }
+
+  return {
+    clearUnsafe() {
+      sentParts.clear()
+    },
+    markParts(parts, responseId) {
+      for (let i = 0; i < parts.length; i++) {
+        sentParts.set(parts[i], responseId)
+      }
+    },
+    prepareUnsafe(prompt) {
+      const messages = prompt.content
+
+      let anyTracked = false
+      for (let i = 0; i < messages.length; i++) {
+        if (sentParts.has(messages[i])) {
+          anyTracked = true
+          break
+        }
+      }
+      if (!anyTracked) return none()
+
+      let lastAssistantIndex = -1
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "assistant") {
+          lastAssistantIndex = i
+          break
+        }
+      }
+      if (lastAssistantIndex === -1) return none()
+
+      let responseId: string | undefined
+      for (let i = 0; i < lastAssistantIndex; i++) {
+        const id = sentParts.get(messages[i])
+        if (id === undefined) return none()
+        responseId = id
+      }
+      if (responseId === undefined) return none()
+
+      const partsAfterLastAssistant = messages.slice(lastAssistantIndex + 1)
+      if (partsAfterLastAssistant.length === 0) {
+        return none()
+      }
+
+      return Option.some({
+        previousResponseId: responseId,
+        prompt: Prompt.fromMessages(partsAfterLastAssistant)
+      })
+    }
+  }
+})

package/src/unstable/ai/Telemetry.ts

@@ -31,9 +31,9 @@
  *
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import { dual } from "../../Function.ts"
 import * as Predicate from "../../Predicate.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as String from "../../String.ts"
 import type * as Struct from "../../Struct.ts"
 import type { Span } from "../../Tracer.ts"
@@ -545,6 +545,6 @@ export interface SpanTransformer {
  * @since 4.0.0
  * @category services
  */
-export class CurrentSpanTransformer extends ServiceMap.Service<CurrentSpanTransformer, SpanTransformer>()(
+export class CurrentSpanTransformer extends Context.Service<CurrentSpanTransformer, SpanTransformer>()(
   "effect/ai/Telemetry/CurrentSpanTransformer"
 ) {}

package/src/unstable/ai/Tokenizer.ts

@@ -35,9 +35,9 @@
  *
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Predicate from "../../Predicate.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as AiError from "./AiError.ts"
 import * as Prompt from "./Prompt.ts"
 
@@ -62,7 +62,7 @@ import * as Prompt from "./Prompt.ts"
  * @since 4.0.0
  * @category services
  */
-export class Tokenizer extends ServiceMap.Service<Tokenizer, Service>()(
+export class Tokenizer extends Context.Service<Tokenizer, Service>()(
   "effect/ai/Tokenizer"
 ) {}
 

package/src/unstable/ai/Tool.ts

@@ -26,6 +26,7 @@
  *
  * @since 1.0.0
  */
+import * as Context from "../../Context.ts"
 import type * as Effect from "../../Effect.ts"
 import { constFalse, constTrue, identity } from "../../Function.ts"
 import type * as JsonSchema from "../../JsonSchema.ts"
@@ -33,7 +34,6 @@ import { pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import * as AST from "../../SchemaAST.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Struct from "../../Struct.ts"
 import type * as Types from "../../Types.ts"
 import type * as AiError from "./AiError.ts"
@@ -232,10 +232,10 @@ export interface Tool<
   readonly failureSchema: Config["failure"]
 
   /**
-   * A `ServiceMap` containing tool annotations which can store metadata about
+   * A `Context` containing tool annotations which can store metadata about
    * the tool.
    */
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 
   /**
    * Specifies whether user approval is required before executing this tool.
@@ -257,7 +257,7 @@ export interface Tool<
    * instead of being provided when creating the tool call handler layer.
    */
   addDependency<Identifier, Service>(
-    tag: ServiceMap.Service<Identifier, Service>
+    tag: Context.Key<Identifier, Service>
   ): Tool<Name, Config, Identifier | Requirements>
 
   /**
@@ -311,12 +311,12 @@ export interface Tool<
   /**
    * Add an annotation to the tool.
    */
-  annotate<I, S>(tag: ServiceMap.Service<I, S>, value: S): Tool<Name, Config, Requirements>
+  annotate<I, S>(tag: Context.Key<I, S>, value: S): Tool<Name, Config, Requirements>
 
   /**
    * Add many annotations to the tool.
    */
-  annotateMerge<I>(context: ServiceMap.ServiceMap<I>): Tool<Name, Config, Requirements>
+  annotateMerge<I>(context: Context.Context<I>): Tool<Name, Config, Requirements>
 }
 
 /**
@@ -893,7 +893,7 @@ export type ResultDecodingServices<T> = T extends Tool<
 export interface Handler<Name extends string> {
   readonly _: unique symbol
   readonly name: Name
-  readonly services: ServiceMap.ServiceMap<never>
+  readonly context: Context.Context<never>
   readonly handler: (params: any, ctx: any) => Effect.Effect<any, any>
 }
 
@@ -952,7 +952,7 @@ export type HandlerError<T> = T extends Tool<
   infer _Name,
   infer _Config,
   infer _Requirements
-> ? _Config["failureMode"] extends "error" ? _Config["failure"]["Type"] | AiError.AiError | AiError.AiErrorReason
+> ? _Config["failureMode"] extends "error" ? _Config["failure"]["Type"] | AiError.AiError
   : never
   : never
 
@@ -1006,16 +1006,16 @@ const Proto = {
   setFailure(this: Any, failureSchema: Schema.Top) {
     return userDefinedProto({ ...this, failureSchema })
   },
-  annotate<I, S>(this: Any, tag: ServiceMap.Service<I, S>, value: S) {
+  annotate<I, S>(this: Any, tag: Context.Key<I, S>, value: S) {
     return userDefinedProto({
       ...this,
-      annotations: ServiceMap.add(this.annotations, tag, value)
+      annotations: Context.add(this.annotations, tag, value)
     })
   },
-  annotateMerge<I>(this: Any, context: ServiceMap.ServiceMap<I>) {
+  annotateMerge<I>(this: Any, context: Context.Context<I>) {
     return userDefinedProto({
       ...this,
-      annotations: ServiceMap.merge(this.annotations, context)
+      annotations: Context.merge(this.annotations, context)
     })
   }
 }
@@ -1042,7 +1042,7 @@ const userDefinedProto = <
   readonly parametersSchema: Parameters
   readonly successSchema: Success
   readonly failureSchema: Failure
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
   readonly failureMode: Mode
   readonly needsApproval?: NeedsApproval<Parameters> | undefined
 }): Tool<
@@ -1104,7 +1104,7 @@ const dynamicProto = <
   readonly parametersSchema: Parameters
   readonly successSchema: Success
   readonly failureSchema: Failure
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
   readonly failureMode: Mode
   readonly needsApproval?: NeedsApproval<any> | undefined
   readonly jsonSchema: JsonSchema.JsonSchema | undefined
@@ -1129,6 +1129,9 @@ const dynamicProto = <
  * can call. The tool definition includes parameter validation, success/failure
  * schemas, and optional service dependencies.
  *
+ * If a tool accepts no parameters but still needs an explicit empty object
+ * schema, use {@link EmptyParams}.
+ *
  * @example
  * ```ts
  * import { Schema } from "effect"
@@ -1146,11 +1149,11 @@ const dynamicProto = <
  */
 export const make = <
   const Name extends string,
-  Parameters extends Schema.Top = typeof Schema.Void,
+  Parameters extends Schema.Top = typeof EmptyParams,
   Success extends Schema.Top = typeof Schema.Void,
   Failure extends Schema.Top = typeof Schema.Never,
   Mode extends FailureMode | undefined = undefined,
-  Dependencies extends Array<ServiceMap.Service<any, any>> = []
+  Dependencies extends Array<Context.Key<any, any> | Context.Key<never, any>> = []
 >(name: Name, options?: {
   /**
    * An optional description explaining what the tool does.
@@ -1200,18 +1203,18 @@ export const make = <
     readonly failure: Failure
     readonly failureMode: Mode extends undefined ? "error" : Mode
   },
-  ServiceMap.Service.Identifier<Dependencies[number]>
+  Context.Service.Identifier<Dependencies[number]>
 > => {
   const successSchema = options?.success ?? Schema.Void
   const failureSchema = options?.failure ?? Schema.Never
   return userDefinedProto({
     name,
     description: options?.description,
-    parametersSchema: options?.parameters ?? Schema.Void,
+    parametersSchema: options?.parameters ?? EmptyParams,
     successSchema,
     failureSchema,
     failureMode: options?.failureMode ?? "error",
-    annotations: ServiceMap.empty(),
+    annotations: Context.empty(),
     needsApproval: options?.needsApproval as any
   }) as any
 }
@@ -1341,7 +1344,7 @@ export const dynamic: {
     successSchema,
     failureSchema,
     failureMode: options?.failureMode ?? "error",
-    annotations: ServiceMap.empty(),
+    annotations: Context.empty(),
     needsApproval: options?.needsApproval,
     jsonSchema
   })
@@ -1622,15 +1625,6 @@ export const getJsonSchema = <Tool extends Any>(tool: Tool, options?: {
 export const getJsonSchemaFromSchema = <S extends Schema.Top>(schema: S, options?: {
   readonly transformer?: CodecTransformer
 }): JsonSchema.JsonSchema => {
-  const props = AST.isObjects(schema.ast) ? schema.ast.propertySignatures : []
-  if (props.length === 0) {
-    return {
-      type: "object",
-      properties: {},
-      required: [],
-      additionalProperties: false
-    }
-  }
   if (Predicate.isNotUndefined(options?.transformer)) {
     return options.transformer(schema).jsonSchema
   }
@@ -1659,7 +1653,22 @@ export const getJsonSchemaFromSchema = <S extends Schema.Top>(schema: S, options
  * @since 1.0.0
  * @category annotations
  */
-export class Title extends ServiceMap.Service<Title, string>()("effect/ai/Tool/Title") {}
+export class Title extends Context.Service<Title, string>()("effect/ai/Tool/Title") {}
+
+/**
+ * Annotation for providing tool metadata for MCP.
+ *
+ * @example
+ * ```ts
+ * import { Tool } from "effect/unstable/ai"
+ *
+ * const myCalculatorUi = Tool.make("calculator_ui", {})
+ *   .annotate(Tool.Meta, { ui: { resourceUri: "ui://example/calculator-ui" } })
+ * ```
+ * @since 1.0.0
+ * @category annotations
+ */
+export class Meta extends Context.Service<Meta, Record<string, unknown>>()("effect/ai/Tool/Meta") {}
 
 /**
  * Annotation indicating whether a tool only reads data without making changes.
@@ -1675,7 +1684,7 @@ export class Title extends ServiceMap.Service<Title, string>()("effect/ai/Tool/T
  * @since 1.0.0
  * @category annotations
  */
-export const Readonly = ServiceMap.Reference<boolean>("effect/ai/Tool/Readonly", {
+export const Readonly = Context.Reference<boolean>("effect/ai/Tool/Readonly", {
   defaultValue: constFalse
 })
 
@@ -1693,7 +1702,7 @@ export const Readonly = ServiceMap.Reference<boolean>("effect/ai/Tool/Readonly",
  * @since 1.0.0
  * @category annotations
  */
-export const Destructive = ServiceMap.Reference<boolean>("effect/ai/Tool/Destructive", {
+export const Destructive = Context.Reference<boolean>("effect/ai/Tool/Destructive", {
   defaultValue: constTrue
 })
 
@@ -1711,7 +1720,7 @@ export const Destructive = ServiceMap.Reference<boolean>("effect/ai/Tool/Destruc
  * @since 1.0.0
  * @category annotations
  */
-export const Idempotent = ServiceMap.Reference<boolean>("effect/ai/Tool/Idempotent", {
+export const Idempotent = Context.Reference<boolean>("effect/ai/Tool/Idempotent", {
   defaultValue: constFalse
 })
 
@@ -1729,7 +1738,7 @@ export const Idempotent = ServiceMap.Reference<boolean>("effect/ai/Tool/Idempote
  * @since 1.0.0
  * @category annotations
  */
-export const OpenWorld = ServiceMap.Reference<boolean>("effect/ai/Tool/OpenWorld", {
+export const OpenWorld = Context.Reference<boolean>("effect/ai/Tool/OpenWorld", {
   defaultValue: constTrue
 })
 
@@ -1755,7 +1764,7 @@ export const OpenWorld = ServiceMap.Reference<boolean>("effect/ai/Tool/OpenWorld
  * @since 1.0.0
  * @category annotations
  */
-export const Strict = ServiceMap.Reference<boolean | undefined>("effect/ai/Tool/Strict", {
+export const Strict = Context.Reference<boolean | undefined>("effect/ai/Tool/Strict", {
   defaultValue: () => undefined
 })
 
@@ -1765,7 +1774,7 @@ export const Strict = ServiceMap.Reference<boolean | undefined>("effect/ai/Tool/
  * @since 1.0.0
  * @category utilities
  */
-export const getStrictMode = <T extends Any>(tool: T): boolean | undefined => ServiceMap.get(tool.annotations, Strict)
+export const getStrictMode = <T extends Any>(tool: T): boolean | undefined => Context.get(tool.annotations, Strict)
 
 // Licensed under BSD-3-Clause (below code only)
 // Code adapted from https://github.com/fastify/secure-json-parse/blob/783fcb1b5434709466759847cec974381939673a/index.js
@@ -1860,3 +1869,20 @@ export const unsafeSecureJsonParse = (text: string): unknown => {
     Error.stackTraceLimit = stackTraceLimit
   }
 }
+
+/**
+ * @since 4.0.0
+ */
+export interface EmptyParams extends Schema.$Record<Schema.String, Schema.Never> {}
+
+/**
+ * A schema for tools that accept no parameters.
+ *
+ * @since 4.0.0
+ */
+export const EmptyParams: EmptyParams = Schema.Record(Schema.String, Schema.Never)
+
+/** @internal */
+export function isEmptyParamsRecord(indexSignature: AST.IndexSignature): boolean {
+  return indexSignature.parameter === AST.string && AST.isNever(indexSignature.type)
+}

package/src/unstable/ai/Toolkit.ts

@@ -39,6 +39,7 @@
  * @since 1.0.0
  */
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Fiber from "../../Fiber.ts"
 import { identity } from "../../Function.ts"
@@ -50,12 +51,9 @@ import * as Predicate from "../../Predicate.ts"
 import * as Queue from "../../Queue.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as AiError from "./AiError.ts"
-import { CurrentCodecTransformer } from "./internal/codec-transformer.ts"
-import type { CodecTransformer } from "./LanguageModel.ts"
-import * as Tool from "./Tool.ts"
+import type * as Tool from "./Tool.ts"
 
 const TypeId = "~effect/ai/Toolkit" as const
 
@@ -124,12 +122,12 @@ export interface Toolkit<in out Tools extends Record<string, Tool.Any>> extends
   of<Handlers extends HandlersFrom<Tools>>(handlers: Handlers): Handlers
 
   /**
-   * Converts a toolkit into a `ServiceMap` containing handlers for each tool
+   * Converts a toolkit into a `Context` containing handlers for each tool
    * in the toolkit.
    */
   toHandlers<Handlers extends HandlersFrom<Tools>, EX = never, RX = never>(
     build: Handlers | Effect.Effect<Handlers, EX, RX>
-  ): Effect.Effect<ServiceMap.ServiceMap<Tool.HandlersFor<Tools>>, EX, RX>
+  ): Effect.Effect<Context.Context<Tool.HandlersFor<Tools>>, EX, RX>
 
   /**
    * Converts a toolkit into a `Layer` containing handlers for each tool in the
@@ -268,56 +266,50 @@ const Proto = {
     build: Record<string, (params: any) => any> | Effect.Effect<Record<string, (params: any) => any>>
   ) {
     return Effect.gen({ self: this }, function*() {
-      const services = yield* Effect.services<never>()
+      const services = yield* Effect.context<never>()
       const handlers = Effect.isEffect(build) ? yield* build : build
-      const serviceMap = new Map<string, unknown>()
+      const context = new Map<string, unknown>()
       for (const [name, handler] of Object.entries(handlers)) {
         const tool = this.tools[name]!
-        serviceMap.set(tool.id, { name, handler, services })
+        context.set(tool.id, { name, handler, context: services })
       }
-      return ServiceMap.makeUnsafe(serviceMap)
+      return Context.makeUnsafe(context)
     })
   },
   toLayer(
     this: Toolkit<Record<string, Tool.Any>>,
     build: Record<string, (params: any) => any> | Effect.Effect<Record<string, (params: any) => any>>
   ) {
-    return Layer.effectServices(this.toHandlers(build))
+    return Layer.effectContext(this.toHandlers(build))
   },
   asEffect(this: Toolkit<Record<string, Tool.Any>>) {
     return Effect.gen({ self: this }, function*() {
       const tools = this.tools
 
-      const services = yield* Effect.services<never>()
+      const services = yield* Effect.context<never>()
 
       const schemasCache = new WeakMap<any, {
-        readonly services: ServiceMap.ServiceMap<never>
+        readonly context: Context.Context<never>
         readonly handler: Tool.Handler<any>["handler"]
         readonly decodeParameters: (u: unknown) => Effect.Effect<unknown, Schema.SchemaError>
         readonly decodeResult: (u: unknown) => Effect.Effect<unknown, Schema.SchemaError>
         readonly encodeResult: (u: unknown) => Effect.Effect<unknown, Schema.SchemaError>
       }>()
 
-      const getSchemas = (tool: Tool.Any, transformer: CodecTransformer) => {
+      const getSchemas = (tool: Tool.Any) => {
         let schemas = schemasCache.get(tool)
         if (Predicate.isUndefined(schemas)) {
           const handler = services.mapUnsafe.get(tool.id)! as Tool.Handler<any>
           const resultSchema = tool.failureMode === "return"
             ? Schema.Union([tool.successSchema, tool.failureSchema, AiError.AiError])
             : tool.successSchema
-          // Do not apply the codec transformation to provider defined tools,
-          // as these are defined internal to the Effect AI SDK and should
-          // already have valid schemas
-          const transformedResultSchema = Tool.isProviderDefined(tool)
-            ? resultSchema
-            : transformer(resultSchema).codec
           const decodeParameters = Schema.isSchema(tool.parametersSchema)
             ? Schema.decodeUnknownEffect(tool.parametersSchema) as any
             : (u: unknown) => Effect.succeed(u)
-          const decodeResult = Schema.decodeUnknownEffect(transformedResultSchema) as any
-          const encodeResult = Schema.encodeUnknownEffect(transformedResultSchema) as any
+          const decodeResult = Schema.decodeUnknownEffect(resultSchema) as any
+          const encodeResult = Schema.encodeUnknownEffect(resultSchema) as any
           schemas = {
-            services: handler.services,
+            context: handler.context,
             handler: handler.handler,
             decodeParameters,
             decodeResult,
@@ -349,8 +341,7 @@ const Proto = {
         }
 
         // Fetch cached schemas / handlers for the tool
-        const codecTransformer = yield* CurrentCodecTransformer
-        const schemas = getSchemas(tool, codecTransformer)
+        const schemas = getSchemas(tool)
 
         // Decode the tool call parameters which will be passed to the handler
         const decodedParams = yield* schemas.decodeParameters(params).pipe(
@@ -384,7 +375,7 @@ const Proto = {
 
         const fiber = yield* schemas.handler(decodedParams, context).pipe(
           Effect.flatMap((result) => Queue.offer(queue, { result, isFailure: false, preliminary: false })),
-          Effect.updateServices((input) => ServiceMap.merge(schemas.services, input)),
+          Effect.updateContext((input) => Context.merge(schemas.context, input)),
           Effect.matchCauseEffect({
             onFailure: (cause) => Queue.failCause(queue, cause),
             onSuccess: () => Queue.end(queue)

package/src/unstable/ai/index.ts

@@ -153,6 +153,24 @@ export * as AnthropicStructuredOutput from "./AnthropicStructuredOutput.ts"
  */
 export * as Chat from "./Chat.ts"
 
+/**
+ * The `EmbeddingModel` module provides provider-agnostic text embedding capabilities.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { EmbeddingModel } from "effect/unstable/ai"
+ *
+ * const program = Effect.gen(function*() {
+ *   const model = yield* EmbeddingModel.EmbeddingModel
+ *   return yield* model.embed("hello world")
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ */
+export * as EmbeddingModel from "./EmbeddingModel.ts"
+
 /**
  * The `IdGenerator` module provides a pluggable system for generating unique identifiers
  * for tool calls and other items in the Effect AI SDKs.
@@ -280,7 +298,7 @@ export * as McpServer from "./McpServer.ts"
  *
  * declare const myAnthropicLayer: Layer.Layer<LanguageModel.LanguageModel>
  *
- * const anthropicModel = Model.make("anthropic", myAnthropicLayer)
+ * const anthropicModel = Model.make("anthropic", "claude-3-5-haiku", myAnthropicLayer)
  *
  * const program = Effect.gen(function*() {
  *   const response = yield* LanguageModel.generateText({
@@ -388,6 +406,11 @@ export * as Prompt from "./Prompt.ts"
  */
 export * as Response from "./Response.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as ResponseIdTracker from "./ResponseIdTracker.ts"
+
 /**
  * The `Telemetry` module provides OpenTelemetry integration for operations
  * performed against a large language model provider by defining telemetry

package/src/unstable/ai/internal/codec-transformer.ts

@@ -1,19 +1,13 @@
+import * as JsonSchema from "../../../JsonSchema.ts"
 import * as Schema from "../../../Schema.ts"
-import * as ServiceMap from "../../../ServiceMap.ts"
 import type { CodecTransformer } from "../LanguageModel.ts"
 
 /** @internal */
 export const defaultCodecTransformer: CodecTransformer = (codec) => {
-  const document = Schema.toJsonSchemaDocument(codec)
-  const jsonSchema = document.schema
+  const document = JsonSchema.resolveTopLevel$ref(Schema.toJsonSchemaDocument(codec))
+  const jsonSchema = { ...document.schema }
   if (Object.keys(document.definitions).length > 0) {
     jsonSchema.$defs = document.definitions
   }
   return { codec, jsonSchema }
 }
-
-/** @internal */
-export const CurrentCodecTransformer = ServiceMap.Reference(
-  "effect/unstable/ai/CodecTransformer",
-  { defaultValue: (): CodecTransformer => defaultCodecTransformer }
-)

package/src/unstable/cli/Argument.ts

@@ -11,7 +11,6 @@ import type * as Schema from "../../Schema.ts"
 import type * as CliError from "./CliError.ts"
 import * as Param from "./Param.ts"
 import type * as Primitive from "./Primitive.ts"
-import type * as Prompt from "./Prompt.ts"
 
 // -------------------------------------------------------------------------------------
 // models
@@ -226,9 +225,7 @@ export const fileParse = (
  *   host: Schema.String
  * })
  *
- * const JsonConfigSchema = Schema.fromJsonString(ConfigSchema)
- *
- * const config = Argument.fileSchema("config", JsonConfigSchema)
+ * const config = Argument.fileSchema("config", ConfigSchema)
  * ```
  *
  * @since 4.0.0
@@ -236,7 +233,7 @@ export const fileParse = (
  */
 export const fileSchema = <A>(
   name: string,
-  schema: Schema.Codec<A, string>,
+  schema: Schema.Decoder<A>,
   options?: Primitive.FileSchemaOptions | undefined
 ): Argument<A> => Param.fileSchema(Param.argumentKind, name, schema, options)
 
@@ -456,7 +453,7 @@ export const withFallbackPrompt: {
    * @since 4.0.0
    * @category combinators
    */
-  <B>(prompt: Prompt.Prompt<B>): <A>(self: Argument<A>) => Argument<A | B>
+  <B>(prompt: Param.FallbackPrompt<B>): <A>(self: Argument<A>) => Argument<A | B>
   /**
    * Adds a fallback prompt that is shown when a required argument is missing.
    *
@@ -472,8 +469,8 @@ export const withFallbackPrompt: {
    * @since 4.0.0
    * @category combinators
    */
-  <A, B>(self: Argument<A>, prompt: Prompt.Prompt<B>): Argument<A | B>
-} = dual(2, <A, B>(self: Argument<A>, prompt: Prompt.Prompt<B>) => Param.withFallbackPrompt(self, prompt))
+  <A, B>(self: Argument<A>, prompt: Param.FallbackPrompt<B>): Argument<A | B>
+} = dual(2, <A, B>(self: Argument<A>, prompt: Param.FallbackPrompt<B>) => Param.withFallbackPrompt(self, prompt))
 
 /**
  * Creates a variadic positional argument that accepts multiple values.