@llm4ts/core 0.1.0

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "@llm4ts/core",
+  "version": "0.1.0",
+  "description": "Effect-native LLM contracts, providers, tools, evaluation, and observability",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    "./AgentSession": "./dist/AgentSession.js",
+    "./Capability": "./dist/Capability.js",
+    "./Connector": "./dist/Connector.js",
+    "./ConnectorConfig": "./dist/ConnectorConfig.js",
+    "./ConnectorRegistry": "./dist/ConnectorRegistry.js",
+    "./ContextManagement": "./dist/ContextManagement.js",
+    "./Conversation": "./dist/Conversation.js",
+    "./Errors": "./dist/Errors.js",
+    "./eval/Checks": "./dist/eval/Checks.js",
+    "./eval/Eval": "./dist/eval/Eval.js",
+    "./eval/Evaluator": "./dist/eval/Evaluator.js",
+    "./eval/EvalSuite": "./dist/eval/EvalSuite.js",
+    "./eval/Judge": "./dist/eval/Judge.js",
+    "./HttpClient": "./dist/HttpClient.js",
+    "./LlmService": "./dist/LlmService.js",
+    "./Models": "./dist/Models.js",
+    "./observability/Metrics": "./dist/observability/Metrics.js",
+    "./observability/MeteredLlmService": "./dist/observability/MeteredLlmService.js",
+    "./observability/Redaction": "./dist/observability/Redaction.js",
+    "./observability/StreamRecorder": "./dist/observability/StreamRecorder.js",
+    "./observability/StructuredLogger": "./dist/observability/StructuredLogger.js",
+    "./observability/Tracing": "./dist/observability/Tracing.js",
+    "./ProcessExecutor": "./dist/ProcessExecutor.js",
+    "./providers/AnthropicModels": "./dist/providers/AnthropicModels.js",
+    "./providers/AnthropicProvider": "./dist/providers/AnthropicProvider.js",
+    "./providers/AntigravityConnector": "./dist/providers/AntigravityConnector.js",
+    "./providers/ClaudeAgentSession": "./dist/providers/ClaudeAgentSession.js",
+    "./providers/ClaudeCliConnector": "./dist/providers/ClaudeCliConnector.js",
+    "./providers/CliSupport": "./dist/providers/CliSupport.js",
+    "./providers/CodexConnector": "./dist/providers/CodexConnector.js",
+    "./providers/ConnectorFactories": "./dist/providers/ConnectorFactories.js",
+    "./providers/CopilotConnector": "./dist/providers/CopilotConnector.js",
+    "./providers/CursorConnector": "./dist/providers/CursorConnector.js",
+    "./providers/GeminiApiProvider": "./dist/providers/GeminiApiProvider.js",
+    "./providers/GeminiCliProvider": "./dist/providers/GeminiCliProvider.js",
+    "./providers/GeminiModels": "./dist/providers/GeminiModels.js",
+    "./providers/LmStudioModels": "./dist/providers/LmStudioModels.js",
+    "./providers/LmStudioProvider": "./dist/providers/LmStudioProvider.js",
+    "./providers/MockProvider": "./dist/providers/MockProvider.js",
+    "./providers/GrokCliConnector": "./dist/providers/GrokCliConnector.js",
+    "./providers/OpenAIModels": "./dist/providers/OpenAIModels.js",
+    "./providers/OpenAIProvider": "./dist/providers/OpenAIProvider.js",
+    "./providers/OpenCodeCliConnector": "./dist/providers/OpenCodeCliConnector.js",
+    "./providers/OllamaModels": "./dist/providers/OllamaModels.js",
+    "./providers/OllamaProvider": "./dist/providers/OllamaProvider.js",
+    "./providers/OpenCodeModels": "./dist/providers/OpenCodeModels.js",
+    "./providers/OpenCodeProvider": "./dist/providers/OpenCodeProvider.js",
+    "./providers/PiConnector": "./dist/providers/PiConnector.js",
+    "./RateLimiter": "./dist/RateLimiter.js",
+    "./Streaming": "./dist/Streaming.js",
+    "./StructuredOutput": "./dist/StructuredOutput.js",
+    "./TemporaryFiles": "./dist/TemporaryFiles.js",
+    "./tools/Tool": "./dist/tools/Tool.js",
+    "./tools/ToolCallingExecutor": "./dist/tools/ToolCallingExecutor.js",
+    "./tools/ToolRegistry": "./dist/tools/ToolRegistry.js",
+    "./UsageLimits": "./dist/UsageLimits.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/riccardomerolla/llm4ts.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/riccardomerolla/llm4ts#readme",
+  "bugs": {
+    "url": "https://github.com/riccardomerolla/llm4ts/issues"
+  },
+  "keywords": [
+    "llm",
+    "effect",
+    "ai",
+    "agents",
+    "workflow",
+    "typescript"
+  ],
+  "peerDependencies": {
+    "effect": "^4.0.0-beta.102"
+  },
+  "devDependencies": {
+    "effect": "^4.0.0-beta.102"
+  },
+  "scripts": {
+    "clean": "tsc -b tsconfig.json --clean",
+    "test": "vitest run test"
+  }
+}

package/src/.gitkeep

@@ -0,0 +1 @@
+

package/src/AgentSession.ts

@@ -0,0 +1,69 @@
+import type * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import type * as Stream from "effect/Stream"
+import type { LlmError } from "./Errors.ts"
+import { TokenUsage } from "./Models.ts"
+
+export class SessionTextDelta extends Schema.TaggedClass<SessionTextDelta>()("TextDelta", {
+  text: Schema.String
+}) {}
+
+export class SessionToolUse extends Schema.TaggedClass<SessionToolUse>()("ToolUse", {
+  tool: Schema.String,
+  rawInput: Schema.String,
+  id: Schema.String
+}) {}
+
+export class SessionToolResult extends Schema.TaggedClass<SessionToolResult>()("ToolResult", {
+  id: Schema.String,
+  status: Schema.String,
+  content: Schema.String
+}) {}
+
+export class SessionAskUser extends Schema.TaggedClass<SessionAskUser>()("AskUser", {
+  question: Schema.String
+}) {}
+
+export class SessionApprovalRequest extends Schema.TaggedClass<SessionApprovalRequest>()(
+  "ApprovalRequest",
+  {
+    tool: Schema.String,
+    rawInput: Schema.String,
+    id: Schema.String
+  }
+) {}
+
+export class SessionUsage extends Schema.TaggedClass<SessionUsage>()("Usage", {
+  usage: TokenUsage,
+  model: Schema.optionalKey(Schema.String)
+}) {}
+
+export class SessionDone extends Schema.TaggedClass<SessionDone>()("Done", {
+  result: Schema.String
+}) {}
+
+export const SessionEvent = Schema.Union([
+  SessionTextDelta,
+  SessionToolUse,
+  SessionToolResult,
+  SessionAskUser,
+  SessionApprovalRequest,
+  SessionUsage,
+  SessionDone
+])
+export type SessionEvent = typeof SessionEvent.Type
+
+export class SessionResult extends Schema.Class<SessionResult>("SessionResult")({
+  text: Schema.String,
+  usage: Schema.optionalKey(TokenUsage),
+  model: Schema.optionalKey(Schema.String)
+}) {}
+
+export interface AgentSessionShape {
+  readonly events: Stream.Stream<SessionEvent, LlmError>
+  readonly sendUserMessage: (text: string) => Effect.Effect<void, LlmError>
+  readonly respondToAsk: (answer: string) => Effect.Effect<void, LlmError>
+  readonly respondToApproval: (id: string, approved: boolean) => Effect.Effect<void, LlmError>
+  readonly awaitResult: Effect.Effect<SessionResult, LlmError>
+  readonly cancel: Effect.Effect<void>
+}

package/src/Capability.ts

@@ -0,0 +1,240 @@
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+
+export class GitRead extends Schema.TaggedClass<GitRead>()("GitRead", {}) {}
+export class GitWrite extends Schema.TaggedClass<GitWrite>()("GitWrite", {}) {}
+export class GitPush extends Schema.TaggedClass<GitPush>()("GitPush", {}) {}
+export class GhRead extends Schema.TaggedClass<GhRead>()("GhRead", {}) {}
+export class GhWrite extends Schema.TaggedClass<GhWrite>()("GhWrite", {}) {}
+export class AdoRead extends Schema.TaggedClass<AdoRead>()("AdoRead", {}) {}
+export class AdoWrite extends Schema.TaggedClass<AdoWrite>()("AdoWrite", {}) {}
+export class Exec extends Schema.TaggedClass<Exec>()("Exec", {
+  command: Schema.String
+}) {}
+export class UseCoder extends Schema.TaggedClass<UseCoder>()("UseCoder", {}) {}
+export class UseReasoning extends Schema.TaggedClass<UseReasoning>()("UseReasoning", {}) {}
+export class Declassify extends Schema.TaggedClass<Declassify>()("Declassify", {}) {}
+
+export const Capability = Schema.Union([
+  GitRead,
+  GitWrite,
+  GitPush,
+  GhRead,
+  GhWrite,
+  AdoRead,
+  AdoWrite,
+  Exec,
+  UseCoder,
+  UseReasoning,
+  Declassify
+])
+export type Capability = typeof Capability.Type
+
+export const Capabilities = Object.freeze({
+  Schema: Capability,
+  GitRead: new GitRead(),
+  GitWrite: new GitWrite(),
+  GitPush: new GitPush(),
+  GhRead: new GhRead(),
+  GhWrite: new GhWrite(),
+  AdoRead: new AdoRead(),
+  AdoWrite: new AdoWrite(),
+  Exec: (command: string): Exec => new Exec({ command }),
+  UseCoder: new UseCoder(),
+  UseReasoning: new UseReasoning(),
+  Declassify: new Declassify()
+})
+
+export const GrantLevel = Schema.Literals(["None", "Read", "Write", "Push"])
+export type GrantLevel = typeof GrantLevel.Type
+
+const levelRank = (level: GrantLevel): number => {
+  switch (level) {
+    case "None":
+      return 0
+    case "Read":
+      return 1
+    case "Write":
+      return 2
+    case "Push":
+      return 3
+  }
+}
+
+const minLevel = (first: GrantLevel, second: GrantLevel): GrantLevel =>
+  levelRank(first) <= levelRank(second) ? first : second
+
+const maxLevel = (first: GrantLevel, second: GrantLevel): GrantLevel =>
+  levelRank(first) >= levelRank(second) ? first : second
+
+export class ExecDenied extends Schema.TaggedClass<ExecDenied>()("Denied", {}) {}
+export class ExecAllow extends Schema.TaggedClass<ExecAllow>()("Allow", {
+  commands: Schema.ReadonlySet(Schema.String)
+}) {}
+export class ExecAll extends Schema.TaggedClass<ExecAll>()("All", {}) {}
+
+export const ExecGrant = Schema.Union([ExecDenied, ExecAllow, ExecAll])
+export type ExecGrant = typeof ExecGrant.Type
+
+export const ExecGrants = Object.freeze({
+  Denied: new ExecDenied(),
+  All: new ExecAll()
+})
+
+export const allowExec = (commands: Iterable<string>): ExecAllow =>
+  new ExecAllow({ commands: new Set(commands) })
+
+const intersectExec = (first: ExecGrant, second: ExecGrant): ExecGrant => {
+  if (first._tag === "Denied" || second._tag === "Denied") {
+    return ExecGrants.Denied
+  }
+  if (first._tag === "All") {
+    return second
+  }
+  if (second._tag === "All") {
+    return first
+  }
+  return allowExec([...first.commands].filter((command) => second.commands.has(command)))
+}
+
+const unionExec = (first: ExecGrant, second: ExecGrant): ExecGrant => {
+  if (first._tag === "All" || second._tag === "All") {
+    return ExecGrants.All
+  }
+  if (first._tag === "Denied") {
+    return second
+  }
+  if (second._tag === "Denied") {
+    return first
+  }
+  return allowExec(new Set([...first.commands, ...second.commands]))
+}
+
+export class Grants extends Schema.Class<Grants>("Grants")({
+  git: GrantLevel,
+  gh: GrantLevel,
+  ado: GrantLevel,
+  exec: ExecGrant,
+  coder: Schema.Boolean,
+  reasoning: Schema.Boolean,
+  declassify: Schema.Boolean
+}) {}
+
+export const allGrants = new Grants({
+  git: "Push",
+  gh: "Write",
+  ado: "Write",
+  exec: ExecGrants.All,
+  coder: true,
+  reasoning: true,
+  declassify: true
+})
+
+export const noneGrants = new Grants({
+  git: "None",
+  gh: "None",
+  ado: "None",
+  exec: ExecGrants.Denied,
+  coder: false,
+  reasoning: false,
+  declassify: false
+})
+
+export const intersectGrants = (first: Grants, second: Grants): Grants =>
+  new Grants({
+    git: minLevel(first.git, second.git),
+    gh: minLevel(first.gh, second.gh),
+    ado: minLevel(first.ado, second.ado),
+    exec: intersectExec(first.exec, second.exec),
+    coder: first.coder && second.coder,
+    reasoning: first.reasoning && second.reasoning,
+    declassify: first.declassify && second.declassify
+  })
+
+export const unionGrants = (first: Grants, second: Grants): Grants =>
+  new Grants({
+    git: maxLevel(first.git, second.git),
+    gh: maxLevel(first.gh, second.gh),
+    ado: maxLevel(first.ado, second.ado),
+    exec: unionExec(first.exec, second.exec),
+    coder: first.coder || second.coder,
+    reasoning: first.reasoning || second.reasoning,
+    declassify: first.declassify || second.declassify
+  })
+
+const execAllows = (grant: ExecGrant, command: string): boolean => {
+  switch (grant._tag) {
+    case "Denied":
+      return false
+    case "Allow":
+      return grant.commands.has(command)
+    case "All":
+      return true
+  }
+}
+
+export const allows = (grants: Grants, capability: Capability): boolean => {
+  switch (capability._tag) {
+    case "GitRead":
+      return levelRank(grants.git) >= levelRank("Read")
+    case "GitWrite":
+      return levelRank(grants.git) >= levelRank("Write")
+    case "GitPush":
+      return levelRank(grants.git) >= levelRank("Push")
+    case "GhRead":
+      return levelRank(grants.gh) >= levelRank("Read")
+    case "GhWrite":
+      return levelRank(grants.gh) >= levelRank("Write")
+    case "AdoRead":
+      return levelRank(grants.ado) >= levelRank("Read")
+    case "AdoWrite":
+      return levelRank(grants.ado) >= levelRank("Write")
+    case "Exec":
+      return execAllows(grants.exec, capability.command)
+    case "UseCoder":
+      return grants.coder
+    case "UseReasoning":
+      return grants.reasoning
+    case "Declassify":
+      return grants.declassify
+  }
+}
+
+const CurrentGrants = Context.Reference<Grants>("@llm4ts/core/CurrentGrants", {
+  defaultValue: () => allGrants
+})
+
+export const currentGrants: Effect.Effect<Grants> = Effect.map(CurrentGrants, (grants) => grants)
+
+export const restricted =
+  (grants: Grants) =>
+  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.flatMap(CurrentGrants, (current) =>
+      Effect.provideService(effect, CurrentGrants, intersectGrants(current, grants))
+    )
+
+export class CapabilityDenied extends Schema.TaggedErrorClass<CapabilityDenied>()(
+  "CapabilityDenied",
+  {
+    required: Schema.Array(Capability),
+    granted: Grants
+  }
+) {
+  get message(): string {
+    const names = this.required.map((capability) =>
+      capability._tag === "Exec" ? `Exec(${capability.command})` : capability._tag
+    )
+    return `missing required capabilities: ${names.join(", ")}`
+  }
+}
+
+export const requireCapabilities =
+  (required: ReadonlyArray<Capability>) =>
+  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | CapabilityDenied, R> =>
+    Effect.flatMap(CurrentGrants, (granted): Effect.Effect<A, E | CapabilityDenied, R> => {
+      const missing = required.filter((capability) => !allows(granted, capability))
+      return missing.length === 0
+        ? effect
+        : Effect.fail(new CapabilityDenied({ required: missing, granted }))
+    })

package/src/Connector.ts

@@ -0,0 +1,220 @@
+import * as Clock from "effect/Clock"
+import * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import type * as Stream from "effect/Stream"
+import { CliSandbox } from "./ConnectorConfig.ts"
+import { InvalidRequestError, type LlmError } from "./Errors.ts"
+import type { LlmServiceShape, StructuredResult } from "./LlmService.ts"
+import {
+  ConnectorCapabilities,
+  HealthStatus,
+  type ConnectorId,
+  type ConnectorKind,
+  type InteractionSupport,
+  type JsonSchema,
+  type LlmChunk,
+  type Message,
+  type ToolCallResponse,
+  type ToolDefinition
+} from "./Models.ts"
+import type { ProcessExecutorShape } from "./ProcessExecutor.ts"
+import { parseFromText, withSchemaHint } from "./StructuredOutput.ts"
+
+export interface ConnectorShape extends LlmServiceShape {
+  readonly id: ConnectorId
+  readonly kind: ConnectorKind
+  readonly healthCheck: Effect.Effect<HealthStatus, LlmError>
+  readonly capabilities: ConnectorCapabilities
+}
+
+export interface ApiConnectorShape extends ConnectorShape {
+  readonly kind: "Api"
+}
+
+export class CliContext extends Schema.Class<CliContext>("CliContext")({
+  worktreePath: Schema.String,
+  repoPath: Schema.String,
+  envVars: Schema.Record(Schema.String, Schema.String).pipe(
+    Schema.withConstructorDefault(Effect.succeed(Object.freeze({})))
+  ),
+  sandbox: Schema.optionalKey(CliSandbox),
+  turnLimit: Schema.optionalKey(Schema.Int)
+}) {}
+
+export interface CliConnectorShape extends ConnectorShape {
+  readonly kind: "Cli"
+  readonly interactionSupport: InteractionSupport
+  readonly buildArgv: (prompt: string, context: CliContext) => ReadonlyArray<string>
+  readonly buildInteractiveArgv: (context: CliContext) => ReadonlyArray<string>
+  readonly complete: (prompt: string) => Effect.Effect<string, LlmError>
+  readonly completeStream: (prompt: string) => Stream.Stream<LlmChunk, LlmError>
+}
+
+export const apiConnectorCapabilities = (): ConnectorCapabilities => ConnectorCapabilities.make({})
+
+export const timedHealthCheck = (
+  isAvailable: Effect.Effect<boolean>
+): Effect.Effect<HealthStatus, LlmError> =>
+  Effect.gen(function* () {
+    const startedAt = yield* Clock.currentTimeNanos
+    const available = yield* isAvailable
+    const completedAt = yield* Clock.currentTimeNanos
+    return HealthStatus.make({
+      availability: available ? "Healthy" : "Unhealthy",
+      authStatus: available ? "Valid" : "Invalid",
+      latency: Duration.nanos(completedAt - startedAt)
+    })
+  })
+
+export interface ApiConnectorPrimitives {
+  readonly id: ConnectorId
+  readonly executeStream: (prompt: string) => Stream.Stream<LlmChunk, LlmError>
+  readonly executeStreamWithHistory: (
+    messages: ReadonlyArray<Message>
+  ) => Stream.Stream<LlmChunk, LlmError>
+  readonly executeWithTools: (
+    prompt: string,
+    tools: ReadonlyArray<ToolDefinition>
+  ) => Effect.Effect<ToolCallResponse, LlmError>
+  readonly executeStructuredWithUsage: <A, E, RD, RE>(
+    prompt: string,
+    schema: Schema.ConstraintCodec<A, E, RD, RE>,
+    jsonSchema: JsonSchema
+  ) => Effect.Effect<StructuredResult<A>, LlmError, RD>
+  readonly isAvailable: Effect.Effect<boolean>
+  readonly capabilities?: ConnectorCapabilities
+}
+
+export const makeApiConnector = (primitives: ApiConnectorPrimitives): ApiConnectorShape => {
+  const executeStructured = <A, E, RD, RE>(
+    prompt: string,
+    schema: Schema.ConstraintCodec<A, E, RD, RE>,
+    jsonSchema: JsonSchema
+  ): Effect.Effect<A, LlmError, RD> =>
+    Effect.map(
+      primitives.executeStructuredWithUsage(prompt, schema, jsonSchema),
+      ([value]) => value
+    )
+
+  return {
+    ...primitives,
+    kind: "Api",
+    capabilities: primitives.capabilities ?? apiConnectorCapabilities(),
+    healthCheck: timedHealthCheck(primitives.isAvailable),
+    executeStructured
+  }
+}
+
+export const cliConnectorCapabilities = (
+  interactionSupport: InteractionSupport
+): ConnectorCapabilities =>
+  ConnectorCapabilities.make({
+    interactiveSessions: interactionSupport === "InteractiveStdin"
+  })
+
+export const flattenHistory = (messages: ReadonlyArray<Message>): string => {
+  const systemBlock = messages
+    .filter((message) => message.role === "System" && message.content.length > 0)
+    .map((message) => message.content)
+    .join("\n\n")
+  const turns = messages
+    .filter((message) => message.role !== "System")
+    .map((message) => `**${message.role}:** ${message.content}`)
+    .join("\n\n")
+
+  return `${systemBlock.length === 0 ? "" : `${systemBlock}\n\n`}${turns}`
+}
+
+export interface CliVersionProbe {
+  readonly executor: ProcessExecutorShape
+  readonly binary: string
+  readonly versionArgs?: ReadonlyArray<string>
+  readonly cwd?: string
+}
+
+const cliProbeHealthy = HealthStatus.make({ availability: "Healthy", authStatus: "Valid" })
+const cliProbeUnhealthy = HealthStatus.make({ availability: "Unhealthy", authStatus: "Unknown" })
+
+export const cliVersionProbeHealthCheck = (
+  probe: CliVersionProbe
+): Effect.Effect<HealthStatus, LlmError> =>
+  probe.executor
+    .run([probe.binary, ...(probe.versionArgs ?? ["--version"])], probe.cwd ?? ".", {})
+    .pipe(
+      Effect.as(cliProbeHealthy),
+      Effect.catch(() => Effect.succeed(cliProbeUnhealthy))
+    )
+
+export interface CliConnectorPrimitives {
+  readonly id: ConnectorId
+  readonly interactionSupport: InteractionSupport
+  readonly buildArgv: (prompt: string, context: CliContext) => ReadonlyArray<string>
+  readonly buildInteractiveArgv: (context: CliContext) => ReadonlyArray<string>
+  readonly complete: (prompt: string) => Effect.Effect<string, LlmError>
+  readonly completeStream: (prompt: string) => Stream.Stream<LlmChunk, LlmError>
+  readonly versionProbe?: CliVersionProbe
+  readonly healthCheck?: Effect.Effect<HealthStatus, LlmError>
+  readonly isAvailable?: Effect.Effect<boolean>
+  readonly capabilities?: ConnectorCapabilities
+}
+
+const unsupportedTools = (
+  id: ConnectorId,
+  _prompt: string,
+  _tools: ReadonlyArray<ToolDefinition>
+): Effect.Effect<ToolCallResponse, LlmError> =>
+  Effect.fail(
+    InvalidRequestError.make({
+      message: `CLI connector ${id.value} does not support tool calling`
+    })
+  )
+
+export const makeCliConnector = (primitives: CliConnectorPrimitives): CliConnectorShape => {
+  const executeStructured = <A, E, RD, RE>(
+    prompt: string,
+    schema: Schema.ConstraintCodec<A, E, RD, RE>,
+    jsonSchema: JsonSchema
+  ): Effect.Effect<A, LlmError, RD> =>
+    Effect.flatMap(primitives.complete(withSchemaHint(prompt, jsonSchema)), (text) =>
+      parseFromText(text, schema, jsonSchema)
+    )
+
+  const executeStructuredWithUsage = <A, E, RD, RE>(
+    prompt: string,
+    schema: Schema.ConstraintCodec<A, E, RD, RE>,
+    jsonSchema: JsonSchema
+  ): Effect.Effect<StructuredResult<A>, LlmError, RD> =>
+    Effect.map(executeStructured(prompt, schema, jsonSchema), (value) => [
+      value,
+      undefined,
+      undefined
+    ])
+
+  const healthCheck =
+    primitives.healthCheck ??
+    (primitives.versionProbe === undefined
+      ? Effect.succeed(HealthStatus.make({ availability: "Unknown", authStatus: "Unknown" }))
+      : cliVersionProbeHealthCheck(primitives.versionProbe))
+
+  const isAvailable =
+    primitives.isAvailable ??
+    healthCheck.pipe(
+      Effect.map((status) => status.availability === "Healthy"),
+      Effect.catch(() => Effect.succeed(false))
+    )
+
+  return {
+    ...primitives,
+    kind: "Cli",
+    capabilities:
+      primitives.capabilities ?? cliConnectorCapabilities(primitives.interactionSupport),
+    healthCheck,
+    isAvailable,
+    executeStream: primitives.completeStream,
+    executeStreamWithHistory: (messages) => primitives.completeStream(flattenHistory(messages)),
+    executeWithTools: (prompt, tools) => unsupportedTools(primitives.id, prompt, tools),
+    executeStructured,
+    executeStructuredWithUsage
+  }
+}