effect 4.0.0-beta.30 → 4.0.0-beta.32

package/src/unstable/ai/AnthropicStructuredOutput.ts

@@ -22,6 +22,7 @@ import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import * as AST from "../../SchemaAST.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
+import * as Tool from "./Tool.ts"
 
 /**
  * Transforms a `Schema.Codec` into a form compatible with Anthropic's
@@ -225,6 +226,9 @@ function recur(ast: AST.AST): AST.AST {
         }
       } else if (ast.indexSignatures.length === 1 && ast.propertySignatures.length === 0) {
         const is = ast.indexSignatures[0]
+        if (Tool.isEmptyParamsRecord(is)) {
+          return ast
+        }
         // records are not supported by Anthropic, so we translate them to arrays of key-value pairs
         if (annotations !== undefined && typeof annotations.description === "string") {
           annotations.description = `${RECORD_DESCRIPTION}; ${annotations.description}`

package/src/unstable/ai/Chat.ts

@@ -64,7 +64,6 @@ import * as IdGenerator from "./IdGenerator.ts"
 import * as LanguageModel from "./LanguageModel.ts"
 import * as Prompt from "./Prompt.ts"
 import type * as Response from "./Response.ts"
-import type * as Tool from "./Tool.ts"
 
 /**
  * The `Chat` service tag for dependency injection.
@@ -200,10 +199,9 @@ export interface Service {
    * ```
    */
   readonly generateText: <
-    Options extends NoExcessProperties<LanguageModel.GenerateTextOptions<any>, Options>,
-    Tools extends Record<string, Tool.Any> = {}
-  >(options: Options & LanguageModel.GenerateTextOptions<Tools>) => Effect.Effect<
-    LanguageModel.GenerateTextResponse<Tools>,
+    Options extends NoExcessProperties<LanguageModel.GenerateTextOptions<any>, Options>
+  >(options: Options & LanguageModel.GenerateTextOptions<LanguageModel.ExtractTools<Options>>) => Effect.Effect<
+    LanguageModel.GenerateTextResponse<LanguageModel.ExtractTools<Options>>,
     LanguageModel.ExtractError<Options>,
     LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
   >
@@ -234,10 +232,9 @@ export interface Service {
    * ```
    */
   readonly streamText: <
-    Options extends NoExcessProperties<LanguageModel.GenerateTextOptions<any>, Options>,
-    Tools extends Record<string, Tool.Any> = {}
-  >(options: Options & LanguageModel.GenerateTextOptions<Tools>) => Stream.Stream<
-    Response.StreamPart<Tools>,
+    Options extends NoExcessProperties<LanguageModel.GenerateTextOptions<any>, Options>
+  >(options: Options & LanguageModel.GenerateTextOptions<LanguageModel.ExtractTools<Options>>) => Stream.Stream<
+    Response.StreamPart<LanguageModel.ExtractTools<Options>>,
     LanguageModel.ExtractError<Options>,
     LanguageModel.LanguageModel | LanguageModel.ExtractServices<Options>
   >
@@ -278,10 +275,11 @@ export interface Service {
   readonly generateObject: <
     ObjectEncoded extends Record<string, any>,
     ObjectSchema extends Schema.Encoder<ObjectEncoded, unknown>,
-    Options extends NoExcessProperties<LanguageModel.GenerateObjectOptions<any, ObjectSchema>, Options>,
-    Tools extends Record<string, Tool.Any> = {}
-  >(options: Options & LanguageModel.GenerateObjectOptions<Tools, ObjectSchema>) => Effect.Effect<
-    LanguageModel.GenerateObjectResponse<Tools, ObjectSchema["Type"]>,
+    Options extends NoExcessProperties<LanguageModel.GenerateObjectOptions<any, ObjectSchema>, Options>
+  >(
+    options: Options & LanguageModel.GenerateObjectOptions<LanguageModel.ExtractTools<Options>, ObjectSchema>
+  ) => Effect.Effect<
+    LanguageModel.GenerateObjectResponse<LanguageModel.ExtractTools<Options>, ObjectSchema["Type"]>,
     LanguageModel.ExtractError<Options>,
     LanguageModel.ExtractServices<Options> | ObjectSchema["DecodingServices"] | LanguageModel.LanguageModel
   >
@@ -698,7 +696,9 @@ export const makePersisted = Effect.fnUntraced(function*(options: {
           yield* Ref.set(chat.history, history)
           // Export the chat history
           const exported = yield* Effect.orDie(chat.export)
-          const timeToLive = Predicate.isNotUndefined(ttl) ? Duration.fromInput(ttl) : undefined
+          const timeToLive = Predicate.isNotUndefined(ttl)
+            ? Option.getOrUndefined(Duration.fromInput(ttl))
+            : undefined
           // Save the chat to the backing store
           yield* store.set(chatId, exported as object, timeToLive)
         }
@@ -740,7 +740,9 @@ export const makePersisted = Effect.fnUntraced(function*(options: {
       // Export the chat history
       const history = yield* Effect.orDie(chat.export)
       // Save the history for the newly created chat
-      const timeToLive = Predicate.isNotUndefined(ttl) ? Duration.fromInput(ttl) : undefined
+      const timeToLive = Predicate.isNotUndefined(ttl)
+        ? Option.getOrUndefined(Duration.fromInput(ttl))
+        : undefined
       yield* store.set(chatId, history as object, timeToLive)
       // Convert the chat to a persisted chat
       return yield* toPersisted(chatId, chat, ttl)

package/src/unstable/ai/LanguageModel.ts

@@ -205,15 +205,7 @@ export interface GenerateTextOptions<Tools extends Record<string, Tool.Any>> {
    * A toolkit containing both the tools and the tool call handler to use to
    * augment text generation.
    */
-  readonly toolkit?:
-    | Toolkit.WithHandler<Tools>
-    | Effect.Yieldable<
-      Toolkit.Toolkit<Tools>,
-      Toolkit.WithHandler<Tools>,
-      never,
-      any
-    >
-    | undefined
+  readonly toolkit?: ToolkitOption<Tools> | undefined
 
   /**
    * The tool choice mode for the language model.
@@ -467,6 +459,89 @@ export class GenerateObjectResponse<
 // Utility Types
 // =============================================================================
 
+/**
+ * The supported toolkit option shapes for language model operations.
+ *
+ * @since 4.0.0
+ * @category utility types
+ */
+export type ToolkitOption<
+  Tools extends Record<string, Tool.Any>,
+  E = never,
+  R = any
+> = Tools extends any ? (
+    | Toolkit.WithHandler<Tools>
+    | Effect.Yieldable<
+      Toolkit.Toolkit<Tools>,
+      Toolkit.WithHandler<Tools>,
+      E,
+      R
+    >
+  )
+  : never
+
+type ExtractToolsFromToolkitOption<ToolkitValue> = ToolkitValue extends Toolkit.WithHandler<infer Tools> ? Tools
+  : ToolkitValue extends Effect.Yieldable<
+    Toolkit.Toolkit<infer Tools>,
+    Toolkit.WithHandler<infer _Tools>,
+    infer _E,
+    infer _R
+  > ? Tools
+  : never
+
+/**
+ * Utility type that extracts the toolset from LanguageModel options.
+ *
+ * @since 4.0.0
+ * @category utility types
+ */
+export type ExtractTools<Options> = Options extends {
+  readonly toolkit: infer ToolkitValue
+} ? ExtractToolsFromToolkitOption<Exclude<ToolkitValue, undefined>>
+  : {}
+
+type ExtractErrorFromToolkitOption<ToolkitValue, DisableToolCallResolution extends boolean> = ToolkitValue extends
+  Toolkit.WithHandler<infer Tools> ?
+    | AiError.AiError
+    | (DisableToolCallResolution extends true ? never : Tool.HandlerError<Tools[keyof Tools]>)
+  : ToolkitValue extends Effect.Yieldable<
+    Toolkit.Toolkit<infer Tools>,
+    Toolkit.WithHandler<infer _Tools>,
+    infer E,
+    infer _R
+  > ? AiError.AiError | E | (DisableToolCallResolution extends true ? never : Tool.HandlerError<Tools[keyof Tools]>)
+  : AiError.AiError
+
+type ExtractServicesFromToolkitOption<ToolkitValue> = ToolkitValue extends Toolkit.WithHandler<infer Tools> ?
+    | Tool.HandlerServices<Tools[keyof Tools]>
+    | Tool.ResultDecodingServices<Tools[keyof Tools]>
+  : ToolkitValue extends Effect.Yieldable<
+    Toolkit.Toolkit<infer Tools>,
+    Toolkit.WithHandler<infer _Tools>,
+    infer _E,
+    infer R
+  > ?
+      | Tool.HandlerServices<Tools[keyof Tools]>
+      | Tool.ResultDecodingServices<Tools[keyof Tools]>
+      | R
+  : never
+
+type ExtractToolkitResolutionError<ToolkitValue> = ToolkitValue extends Effect.Yieldable<
+  Toolkit.Toolkit<infer _Tools>,
+  Toolkit.WithHandler<infer _Tools>,
+  infer E,
+  infer _R
+> ? E
+  : never
+
+type ExtractToolkitResolutionServices<ToolkitValue> = ToolkitValue extends Effect.Yieldable<
+  Toolkit.Toolkit<infer _Tools>,
+  Toolkit.WithHandler<infer _Tools>,
+  infer _E,
+  infer R
+> ? R
+  : never
+
 /**
  * Utility type that extracts the error type from LanguageModel options.
  *
@@ -477,29 +552,15 @@ export class GenerateObjectResponse<
  * @category utility types
  */
 export type ExtractError<Options> = Options extends {
-  readonly toolkit: Toolkit.WithHandler<infer _Tools>
   readonly disableToolCallResolution: true
-} ? AiError.AiError
+  readonly toolkit: infer ToolkitValue
+} ? ExtractErrorFromToolkitOption<Exclude<ToolkitValue, undefined>, true>
   : Options extends {
-    readonly toolkit: Effect.Yieldable<
-      Toolkit.Toolkit<infer _Tools>,
-      Toolkit.WithHandler<infer _Tools>,
-      infer _E,
-      infer _R
-    >
-    readonly disableToolCallResolution: true
-  } ? AiError.AiError | _E
+    readonly toolkit: infer ToolkitValue
+  } ? ExtractErrorFromToolkitOption<Exclude<ToolkitValue, undefined>, false>
   : Options extends {
-    readonly toolkit: Toolkit.WithHandler<infer _Tools>
-  } ? AiError.AiError | Tool.HandlerError<_Tools[keyof _Tools]>
-  : Options extends {
-    readonly toolkit: Effect.Yieldable<
-      Toolkit.Toolkit<infer _Tools>,
-      Toolkit.WithHandler<infer _Tools>,
-      infer _E,
-      infer _R
-    >
-  } ? AiError.AiError | Tool.HandlerError<_Tools[keyof _Tools]> | _E
+    readonly disableToolCallResolution: true
+  } ? AiError.AiError
   : AiError.AiError
 
 /**
@@ -514,27 +575,8 @@ export type ExtractServices<Options> = Options extends {
   readonly disableToolCallResolution: true
 } ? never
   : Options extends {
-    readonly toolkit: Toolkit.WithHandler<infer _Tools>
-  }
-  // Required for tool call execution
-    ?
-      | Tool.ResultEncodingServices<_Tools[keyof _Tools]>
-      // Required for decoding large language model responses
-      | Tool.ResultDecodingServices<_Tools[keyof _Tools]>
-  : Options extends {
-    readonly toolkit: Effect.Yieldable<
-      Toolkit.Toolkit<infer _Tools>,
-      Toolkit.WithHandler<infer _Tools>,
-      infer _E,
-      infer _R
-    >
-  }
-  // Required for tool call execution
-    ?
-      | Tool.ResultEncodingServices<_Tools[keyof _Tools]>
-      // Required for decoding large language model responses
-      | Tool.ResultDecodingServices<_Tools[keyof _Tools]>
-      | _R
+    readonly toolkit: infer Toolkit
+  } ? ExtractServicesFromToolkitOption<Exclude<Toolkit, undefined>>
   : never
 
 // =============================================================================
@@ -1031,21 +1073,11 @@ export const make: (params: {
       AiError.AiError | Schema.SchemaError,
       IdGenerator
     >,
-    Options extends {
-      readonly toolkit: Effect.Effect<
-        Toolkit.WithHandler<Tools>,
-        infer _E,
-        infer _R
-      >
-    } ? _E
+    Options extends { readonly toolkit: infer ToolkitValue } ?
+      ExtractToolkitResolutionError<Exclude<ToolkitValue, undefined>>
       : never,
-    Options extends {
-      readonly toolkit: Effect.Effect<
-        Toolkit.WithHandler<Tools>,
-        infer _E,
-        infer _R
-      >
-    } ? _R
+    Options extends { readonly toolkit: infer ToolkitValue } ?
+      ExtractToolkitResolutionServices<Exclude<ToolkitValue, undefined>>
       : never
   > = Effect.fnUntraced(function*<
     Tools extends Record<string, Tool.Any>,
@@ -1090,9 +1122,7 @@ export const make: (params: {
     }
 
     // If there is a toolkit resolve and apply it to the provider options
-    const toolkit = "asEffect" in options.toolkit
-      ? yield* options.toolkit
-      : options.toolkit
+    const toolkit = yield* resolveToolkit<Tools, any, any>(options.toolkit)
 
     // If the toolkit is empty, return immediately
     if (Object.values(toolkit.tools).length === 0) {
@@ -1335,20 +1365,27 @@ export const make: (params: {
  * @since 4.0.0
  * @category text generation
  */
-export const generateText = <
-  Options extends NoExcessProperties<GenerateTextOptions<any>, Options>,
-  Tools extends Record<string, Tool.Any> = {}
+export function generateText<
+  Options extends NoExcessProperties<GenerateTextOptions<any>, Options>
 >(
-  options: Options & GenerateTextOptions<Tools>
+  options: Options & GenerateTextOptions<ExtractTools<Options>>
 ): Effect.Effect<
-  GenerateTextResponse<Tools>,
+  GenerateTextResponse<ExtractTools<Options>>,
   ExtractError<Options>,
   LanguageModel | ExtractServices<Options>
-> =>
-  Effect.flatMap(
+>
+export function generateText(
+  options: GenerateTextOptions<any>
+): Effect.Effect<
+  GenerateTextResponse<any>,
+  AiError.AiError,
+  LanguageModel
+> {
+  return Effect.flatMap(
     Effect.service(LanguageModel),
-    (model) => model.generateText(options)
+    (model) => model.generateText(options as any)
   )
+}
 
 /**
  * Generate a structured object from a schema using a language model.
@@ -1382,25 +1419,32 @@ export const generateText = <
  * @since 4.0.0
  * @category object generation
  */
-export const generateObject = <
+export function generateObject<
   ObjectEncoded extends Record<string, any>,
   StructuredOutputSchema extends Schema.Encoder<ObjectEncoded, unknown>,
   Options extends NoExcessProperties<
     GenerateObjectOptions<any, StructuredOutputSchema>,
     Options
-  >,
-  Tools extends Record<string, Tool.Any> = {}
+  >
 >(
-  options: Options & GenerateObjectOptions<Tools, StructuredOutputSchema>
+  options: Options & GenerateObjectOptions<ExtractTools<Options>, StructuredOutputSchema>
 ): Effect.Effect<
-  GenerateObjectResponse<Tools, StructuredOutputSchema["Type"]>,
+  GenerateObjectResponse<ExtractTools<Options>, StructuredOutputSchema["Type"]>,
   ExtractError<Options>,
   ExtractServices<Options> | StructuredOutputSchema["DecodingServices"] | LanguageModel
-> =>
-  Effect.flatMap(
+>
+export function generateObject(
+  options: GenerateObjectOptions<any, Schema.Top>
+): Effect.Effect<
+  GenerateObjectResponse<any, any>,
+  AiError.AiError,
+  LanguageModel
+> {
+  return Effect.flatMap(
     Effect.service(LanguageModel),
-    (model) => model.generateObject(options)
-  )
+    (model) => model.generateObject(options as any)
+  ) as any
+}
 
 /**
  * Generate text using a language model with streaming output.
@@ -1426,20 +1470,27 @@ export const generateObject = <
  * @since 4.0.0
  * @category text generation
  */
-export const streamText = <
-  Options extends NoExcessProperties<GenerateTextOptions<any>, Options>,
-  Tools extends Record<string, Tool.Any> = {}
+export function streamText<
+  Options extends NoExcessProperties<GenerateTextOptions<any>, Options>
 >(
-  options: Options & GenerateTextOptions<Tools>
+  options: Options & GenerateTextOptions<ExtractTools<Options>>
 ): Stream.Stream<
-  Response.StreamPart<Tools>,
+  Response.StreamPart<ExtractTools<Options>>,
   ExtractError<Options>,
   ExtractServices<Options> | LanguageModel
-> =>
-  Stream.unwrap(Effect.map(
+>
+export function streamText(
+  options: GenerateTextOptions<any>
+): Stream.Stream<
+  Response.StreamPart<any>,
+  AiError.AiError,
+  LanguageModel
+> {
+  return Stream.unwrap(Effect.map(
     Effect.service(LanguageModel),
-    (model) => model.streamText(options)
-  ))
+    (model) => model.streamText(options as any)
+  )) as any
+}
 
 // =============================================================================
 // Tool Approval Helpers
@@ -1816,11 +1867,11 @@ const resolveToolCalls = <Tools extends Record<string, Tool.Any>>(
 // =============================================================================
 
 const resolveToolkit = <Tools extends Record<string, Tool.Any>, E, R>(
-  toolkit:
-    | Toolkit.WithHandler<Tools>
-    | Effect.Yieldable<Toolkit.Toolkit<any>, Toolkit.WithHandler<Tools>, E, R>
+  toolkit: ToolkitOption<Tools, E, R>
 ): Effect.Effect<Toolkit.WithHandler<Tools>, E, R> =>
-  "asEffect" in toolkit ? toolkit.asEffect() : Effect.succeed(toolkit)
+  ("asEffect" in toolkit
+    ? toolkit.asEffect()
+    : Effect.succeed(toolkit as unknown as Toolkit.WithHandler<Tools>)) as any
 
 /** @internal */
 export const getObjectName = <StructuredOutputSchema extends Schema.Top>(

package/src/unstable/ai/OpenAiStructuredOutput.ts

@@ -11,6 +11,7 @@ import * as Rec from "../../Record.ts"
 import * as Schema from "../../Schema.ts"
 import * as AST from "../../SchemaAST.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
+import * as Tool from "./Tool.ts"
 
 /**
  * Transforms a `Schema.Codec` into a form compatible with OpenAI's
@@ -243,6 +244,9 @@ function recurOpenAI(ast: AST.AST): AST.AST {
         }
       } else if (ast.indexSignatures.length === 1 && ast.propertySignatures.length === 0) {
         const is = ast.indexSignatures[0]
+        if (Tool.isEmptyParamsRecord(is)) {
+          return ast
+        }
         // records are not supported by OpenAI, so we translate them to arrays of key-value pairs
         if (annotations !== undefined && typeof annotations.description === "string") {
           annotations.description = `${RECORD_DESCRIPTION}; ${annotations.description}`

package/src/unstable/ai/Tool.ts

@@ -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"
@@ -1866,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/cli/Argument.ts

@@ -226,9 +226,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 +234,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)
 

package/src/unstable/cli/CliOutput.ts

@@ -3,6 +3,7 @@
  */
 
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import type * as CliError from "./CliError.ts"
 import type { HelpDoc } from "./HelpDoc.ts"
@@ -44,6 +45,7 @@ export interface Formatter {
    *
    * @example
    * ```ts
+   * import { Option as O } from "effect"
    * import type { HelpDoc } from "effect/unstable/cli"
    * import { CliOutput } from "effect/unstable/cli"
    *
@@ -55,7 +57,7 @@ export interface Formatter {
    *       name: "verbose",
    *       aliases: ["-v"],
    *       type: "boolean",
-   *       description: "Enable verbose output",
+   *       description: O.some("Enable verbose output"),
    *       required: false
    *     }
    *   ],
@@ -63,7 +65,7 @@ export interface Formatter {
    *     {
    *       name: "file",
    *       type: "string",
-   *       description: "Input file to process",
+   *       description: O.some("Input file to process"),
    *       required: true,
    *       variadic: false
    *     }
@@ -459,7 +461,7 @@ const formatHelpDocImpl = (doc: HelpDoc, colors: ColorFunctions): string => {
       const nameType = `${coloredName} ${coloredType}`
 
       const optionalSuffix = arg.required ? "" : colors.dim(" (optional)")
-      const description = (arg.description ?? "") + optionalSuffix
+      const description = Option.getOrElse(arg.description, () => "") + optionalSuffix
 
       return {
         left: nameType,
@@ -491,7 +493,7 @@ const formatHelpDocImpl = (doc: HelpDoc, colors: ColorFunctions): string => {
 
       return {
         left: namesPart + typePart,
-        right: flag.description ?? ""
+        right: Option.getOrElse(flag.description, () => "")
       }
     })
 
@@ -519,7 +521,7 @@ const formatHelpDocImpl = (doc: HelpDoc, colors: ColorFunctions): string => {
 
       return {
         left: namesPart + typePart,
-        right: flag.description ?? ""
+        right: Option.getOrElse(flag.description, () => "")
       }
     })
 

package/src/unstable/cli/Command.ts

@@ -360,10 +360,10 @@ export interface ParsedTokens {
   readonly flags: Record<string, ReadonlyArray<string>>
   readonly arguments: ReadonlyArray<string>
   readonly errors?: ReadonlyArray<CliError.CliError>
-  readonly subcommand?: {
+  readonly subcommand: Option.Option<{
     readonly name: string
     readonly parsedInput: ParsedTokens
-  }
+  }>
 }
 
 /**
@@ -939,17 +939,17 @@ export const withSubcommands: {
   type InternalInput = NextInput & { readonly [SubcommandStateSymbol]?: SubcommandState }
 
   const parse = Effect.fnUntraced(function*(raw: ParsedTokens) {
-    if (!raw.subcommand) {
+    if (Option.isNone(raw.subcommand)) {
       return (yield* impl.parse(raw)) as NextInput
     }
 
-    const sub = byName.get(raw.subcommand.name)
+    const sub = byName.get(raw.subcommand.value.name)
     if (!sub) {
       return (yield* impl.parse(raw)) as NextInput
     }
 
     const context = yield* impl.parseContext(raw)
-    const result = yield* sub.parse(raw.subcommand.parsedInput)
+    const result = yield* sub.parse(raw.subcommand.value.parsedInput)
     return Object.assign({}, context, { [SubcommandStateSymbol]: { name: sub.name, result } }) as NextInput
   })
 

package/src/unstable/cli/Completions.ts

@@ -0,0 +1,36 @@
+/**
+ * @since 4.0.0
+ */
+import * as Bash from "./internal/completions/bash.ts"
+import type * as CommandDescriptor from "./internal/completions/CommandDescriptor.ts"
+import * as Fish from "./internal/completions/fish.ts"
+import * as Zsh from "./internal/completions/zsh.ts"
+
+/**
+ * Shell type used to generate completion scripts.
+ *
+ * @since 4.0.0
+ * @category models
+ */
+export type Shell = "bash" | "zsh" | "fish"
+
+/**
+ * Generates a shell completion script for a command descriptor.
+ *
+ * @since 4.0.0
+ * @category constructors
+ */
+export const generate = (
+  executableName: string,
+  shell: Shell,
+  descriptor: CommandDescriptor.CommandDescriptor
+): string => {
+  switch (shell) {
+    case "bash":
+      return Bash.generate(executableName, descriptor)
+    case "zsh":
+      return Zsh.generate(executableName, descriptor)
+    case "fish":
+      return Fish.generate(executableName, descriptor)
+  }
+}

package/src/unstable/cli/Flag.ts

@@ -304,7 +304,7 @@ export const fileParse = (
  * const ConfigSchema = Schema.Struct({
  *   port: Schema.Number,
  *   host: Schema.String
- * }).pipe(Schema.fromJsonString)
+ * })
  *
  * const config = Flag.fileSchema("config", ConfigSchema, { format: "json" })
  * ```
@@ -314,7 +314,7 @@ export const fileParse = (
  */
 export const fileSchema = <A>(
   name: string,
-  schema: Schema.Codec<A, string>,
+  schema: Schema.Decoder<A>,
   options?: Primitive.FileSchemaOptions | undefined
 ): Flag<A> => Param.fileSchema(Param.flagKind, name, schema, options)