@yolk-sdk/agent 0.1.0-canary.76 → 0.1.0-canary.78

package/README.md

@@ -7,13 +7,13 @@ Root export is intentionally empty. Import feature APIs from explicit subpaths.
 ## Install
 
 ```bash
-pnpm add @yolk-sdk/agent@canary effect@4.0.0-beta.80
+pnpm add @yolk-sdk/agent@canary effect@4.0.0-rc.115
 ```
 
 Add `react` if you use `@yolk-sdk/agent/react` or `@yolk-sdk/agent/voice/react`.
 
 Canary APIs are unstable. Keep all `@yolk-sdk/*` packages on the same version.
-Use the SDK's matching Effect version (`4.0.0-beta.80`) in host code.
+Use the SDK's matching Effect version (`4.0.0-rc.115`) in host code.
 Published package metadata requires Node.js 22+.
 
 ## Subpaths
@@ -37,6 +37,8 @@ Published package metadata requires Node.js 22+.
 | `@yolk-sdk/agent/providers/openai/realtime`            | OpenAI Realtime session config and event codecs                |
 | `@yolk-sdk/agent/providers/openai/speech`              | OpenAI text-to-speech and transcription adapters               |
 | `@yolk-sdk/agent/providers/vercel/ai-gateway-provider` | Vercel AI Gateway Chat Completions provider factory            |
+| `@yolk-sdk/agent/providers/opencode/go-provider`       | OpenCode Go Chat Completions, Messages, and Responses provider |
+| `@yolk-sdk/agent/providers/opencode/usage`             | OpenCode Go subscription-allowance snapshots                   |
 | `@yolk-sdk/agent/providers/anthropic`                  | Anthropic/Claude OAuth and broker helpers                      |
 | `@yolk-sdk/agent/providers/anthropic/claude`           | Claude request and auth helpers                                |
 | `@yolk-sdk/agent/providers/anthropic/usage`            | Claude subscription-allowance snapshots                        |
@@ -60,13 +62,14 @@ import {
   isTerminalAgentEvent,
   makeSubagentRunId,
   ProviderErrorInfo,
+  PlainHitlResponse,
   questionResponseStructuredContent,
   repairDanglingHostToolCalls,
   UserMessage,
   validateNoDanglingHostToolCalls
 } from '@yolk-sdk/agent/protocol'
 import { run } from '@yolk-sdk/agent/loop'
-import { runRuntime } from '@yolk-sdk/agent/runtime'
+import { runRuntime, RuntimeRequest } from '@yolk-sdk/agent/runtime'
 import {
   documentPartFromTextFile,
   initialAgentClientState,
@@ -87,6 +90,8 @@ import {
   resolveTools
 } from '@yolk-sdk/agent/tools'
 import {
+  AgentChatAction,
+  AgentChatPart,
   applyAgentEventToChatProjection,
   makeAgentChatEventProjectionState,
   useAgentChat
@@ -94,6 +99,8 @@ import {
 import { makeVercelAiGatewayProviderLayer } from '@yolk-sdk/agent/providers/vercel/ai-gateway-provider'
 ```
 
+`RuntimeRequest` is a value on `@yolk-sdk/agent/runtime` (`Transcript`, `AppendInput`, `AppendHitlResponse`). Pass `RuntimeRequest.Transcript({ sessionId, messages })` into `runRuntime`. For append requests, omitted or `undefined` `expectedRevision` still means use the loaded log revision (`??`).
+
 Test helpers live behind their own subpath:
 
 ```ts
@@ -107,10 +114,21 @@ and actions for submit, stop, edit, regenerate, delete, tool approval, and quest
 package supplies no components, styling, auth, or route ownership, and React remains an optional
 peer used only by React subpaths.
 
+Chat ADTs on `@yolk-sdk/agent/react` are value constructors: `AgentChatPart`, `ChatToolState`,
+`DeleteChatTurnResult`, `EditChatUserMessageResult`, `RegenerateChatMessagesResult`, `AgentChatItem`,
+`ToolRunState`, `AgentChatAction`, and hook results such as `AgentChatSubmitResult`. They are
+`Data.taggedEnum` plain objects (`_tag` last), not Equal/Hash classes. Duration descriptors use
+`ToolDurationKnown` / `ToolDurationUnknown` (`Schema.TaggedStruct.make` validates those plains).
+Prefer `AgentChatPart.Text({ ... })` over handwritten `{ _tag: 'Text', ... }`, omit absent optionals,
+and discriminate with `$is` (for example `AgentChatSubmitResult.$is('Submitted')(result)`).
+`useAgentChat` dispatches `AgentChatAction` constructors and returns those hook-result values.
+
 By default the hook streams HTTP/NDJSON through `@yolk-sdk/agent/client`. Pass an
 `AgentChatTransport` through the `transport` option to use another runtime. A custom transport
 receives the transcript, session/model options, HITL responses, and an `AbortSignal`, and returns an
-`AsyncIterable<AgentEvent>`; the host still owns endpoint auth and persistence.
+`AsyncIterable<AgentEvent>`; the host still owns endpoint auth and persistence. Custom transport
+rejections are normalized to `AgentTransportError` internally while retaining the original cause.
+Native abort causes stop quietly; other non-Error rejections display `Agent request failed`.
 
 ## Quick start
 
@@ -129,6 +147,22 @@ const program = run({
 // Provide LLM provider, loop config, context transformer, and tool executor layers in the host app.
 ```
 
+Loop composition is those four Layers plus `run` / `runModelTurn` / `runToolBatch`.
+Merge them with `makeAgentLoopLayer`. Omitted tools use `ToolExecutor.unavailable`; omitted transformer/config use identity and `LoopConfig.defaultLayer`.
+Intercept by decorating a service (`decorateLLMProvider`), not with hooks.
+Durable hosts fold model-turn steps with `collectModelTurn`. Use `collectModelTurnAttempt` when the fold must retain partial output after a failed stream. Kernel incomplete streams (zero `Done` events) set optional `LLMError.responseIssue: 'missing_done'` and stay `invalid_response` / `retryable: false`.
+
+```ts
+import { makeAgentLoopLayer } from '@yolk-sdk/agent/loop'
+import { FauxProvider, Reply } from '@yolk-sdk/agent/loop/testing'
+
+const LoopLayer = makeAgentLoopLayer({
+  provider: FauxProvider.layer(Reply.text('ok'))
+})
+```
+
+Guide source: [Loop and runtime](https://github.com/magoz/yolk-sdk/blob/main/apps/docs/content/docs/agent/loop-runtime.mdx#compose-the-loop-layer).
+
 ## OAuth credentials
 
 `@yolk-sdk/agent/oauth` defines provider-neutral access-token, broker, freshness, and credential-source
@@ -157,6 +191,7 @@ limits or apply hidden fallbacks.
 | ---------------------------------- | --------------------- |
 | `makeOpenAiProviderLayer`          | `maxCompletionTokens` |
 | `makeVercelAiGatewayProviderLayer` | `maxCompletionTokens` |
+| `makeOpenCodeGoProviderLayer`      | `maxOutputTokens`     |
 | `makeOpenAiCodexProviderLayer`     | none                  |
 | `makeAnthropicClaudeProviderLayer` | `maxTokens`           |
 | `makeXAiGrokProviderLayer`         | `maxOutputTokens`     |
@@ -167,6 +202,56 @@ require the matching limit configuration. ChatGPT subscription Codex rejects ven
 optional deprecated `maxOutputTokens` compatibility field. `OpenAiProviderLayer` reads both
 `OPENAI_API_KEY` and integer `OPENAI_MAX_COMPLETION_TOKENS` through Effect Config.
 
+OpenCode Go uses API-key authentication with an explicit host-selected `protocol`:
+`chat-completions`, `messages`, or `responses`. Model IDs stay opaque: pass the Go API model ID
+without OpenCode's `opencode-go/` CLI prefix. The SDK does not fetch a catalog or guess the protocol
+from a model name. Check the [Go endpoint catalog](https://opencode.ai/docs/go/#endpoints).
+
+Server-side configuration fragment (the host supplies credentials and model policy):
+
+```ts
+import { Layer, Redacted } from 'effect'
+import { FetchHttpClient } from 'effect/unstable/http'
+import { makeOpenCodeGoProviderLayer } from '@yolk-sdk/agent/providers/opencode/go-provider'
+
+const GoLayer = makeOpenCodeGoProviderLayer({
+  apiKey: Redacted.make(hostOpenCodeGoApiKey),
+  protocol: 'messages',
+  maxOutputTokens: hostModelConfig.maxOutputTokens
+}).pipe(Layer.provide(FetchHttpClient.layer))
+```
+
+The default base URL is `https://opencode.ai/zen/go/v1`. Chat uses non-streamed JSON and Bearer auth;
+Messages uses SSE and `x-api-key`; Responses uses SSE and Bearer auth. All normalize to `LLMEvent`s.
+Messages retains native tool names and system instructions, without Claude OAuth fingerprinting.
+Responses sends `max_output_tokens`, unlike Codex. Go requires a nonempty key and positive safe-integer
+limit at layer construction. `extraHeaders` cannot override required protocol headers, regardless of
+case. Only override `baseUrl` with a trusted proxy because it receives the credential.
+
+Request `reasoningEffort` becomes chat `reasoning_effort`, Messages `output_config.effort` (omitting
+`minimal`), or Responses `reasoning.effort` with `summary: 'auto'`. `reasoningSummary` changes the
+Responses summary mode. Hosts must offer only model-supported efforts and media capabilities.
+Chat preserves provider `reasoning_content` in events and assistant replay. No OAuth, model discovery,
+automatic polling, or example-app UI integration is included.
+
+Read Go subscription allowance separately from per-request token usage (server-side fragment):
+
+```ts
+import { Effect, Redacted } from 'effect'
+import { FetchHttpClient } from 'effect/unstable/http'
+import { fetchOpenCodeGoSubscriptionUsage } from '@yolk-sdk/agent/providers/opencode/usage'
+
+const usageEffect = fetchOpenCodeGoSubscriptionUsage(Redacted.make(hostOpenCodeGoApiKey), {
+  requestTimeoutMs: 10_000
+}).pipe(Effect.provide(FetchHttpClient.layer))
+```
+
+The fixed API-key endpoint returns used percentages/reset instants for `five-hour`, `seven-day`, and
+`monthly` windows. Monthly resets follow the subscription's anniversary, not the first of the month;
+the adapter preserves the provider's timestamp. Missing/invalid percentages are omitted, not treated
+as zero. Treat snapshots as best-effort; hosts own polling, stale-data policy, persistence, and UI.
+The fetcher blocks redirects and sanitizes failures using the shared subscription-usage error types.
+
 Vercel AI Gateway uses its OpenAI-compatible JSON Chat Completions endpoint. Pass either an AI
 Gateway API key or Vercel OIDC token as `apiKey`; `maxCompletionTokens` is sent as Gateway
 `max_tokens`. The env-backed `VercelAiGatewayProviderLayer` tries `AI_GATEWAY_API_KEY` first, then
@@ -204,6 +289,72 @@ When a constraint cannot be represented faithfully, the projection widens the mo
 rather than excluding a valid call. Tool execution remains safe because `makeTool` validates the
 returned arguments against the original Effect Schema before invoking the executor.
 
+Before projection, `toAnthropicClaudeRequestBody` and the Claude provider decode `ToolDef.parameters`
+and `ToolCall.params` as `Schema.Json`. Non-JSON values fail as non-retryable `LLMError` with
+`cause: 'provider_error'`. `ToolDef.parameters` now admits `ToolJsonSchema` at construction;
+`ToolCall.params` stays opaque. Provider admission also catches post-construction forgeries.
+After lone-surrogate rewrite, the request
+body is decoded as JSON again and fails rather than skipping serialization. HTTP error bodies that
+are not JSON still classify from status.
+
+### Tool parameter documents
+
+`ToolDef.parameters` uses `ToolJsonSchema` from `@yolk-sdk/agent/protocol`: a boolean schema or
+plain JSON object. `ToolJsonSchemaObject` is the object arm; `decodeToolJsonSchema` and
+`decodeToolJsonSchemaObject` return `Option`. This checks representation, not JSON Schema semantics.
+Construction/decode preserve admitted identity and accept finite primitives, dense ordinary arrays,
+plain/null-prototype objects, own `__proto__`/`constructor` keys and DAG aliases. Accessors are
+rejected unread; exotic prototypes, hidden/symbol keys, undefined, nonfinite values and cycles fail.
+No Proxy side-effect immunity or immutability is promised. Tool call parameters/results and HITL
+remain opaque. Background wrapping preserves boolean `true`/`false` as the arguments schema;
+reference/resource restrictions still apply at activation.
+
+### OpenAI Chat Completions, Responses, and extraBody
+
+OpenAI Chat Completions and Responses lowering (including Codex) likewise admits
+`ToolDef.parameters` and tool-call `params` as `Schema.Json` before they are copied onto the request
+body. Non-JSON tool documents and arguments fail as non-retryable `LLMError` `provider_error` before
+transport. `ToolDef.parameters` admits `ToolJsonSchema`; `ToolCall.params` stays opaque. Public Codex wrapper
+`OpenAiCodexTool.parameters` remains `unknown`; that field is not a `Schema.Json` input type.
+
+Optional request-body fields such as `max_output_tokens`, `tools`, `parallel_tool_calls`, and
+`reasoning` are omitted unless present — they are not own-property `undefined`. After lone-surrogate
+rewrite, Chat Completions and Responses request bodies are decoded as `Schema.Json` again and fail
+rather than skipping serialization. Inbound HTTP JSON bodies admit `Schema.Json` before class/helper
+consumption (`invalid_response` on failure). Responses SSE event JSON admits `Schema.Json`;
+non-object JSON events are ignored (not failed), while malformed non-JSON event text still fails
+`invalid_response`. First `response.completed` remains terminal. HTTP error bodies stay raw text for
+`classifyProviderFailure`.
+
+`OpenAiProviderConfig.extraBody` takes `OpenAiRequestExtras` (JSON-object input). Lowering
+projects enumerable own string fields into an independent portable-data snapshot. Canonical
+`model`, `messages`, `stream`, `tools`, `parallel_tool_calls`, `max_completion_tokens`, and
+`max_tokens` are discarded **without reading their values**; `reasoning` is also discarded when
+`reasoningEffortFormat` is `reasoning-object`. Root symbols/non-enumerable fields are not projected.
+Surviving accessors are rejected unread. Nested values must be finite JSON data with plain/null
+prototypes or dense ordinary arrays; exotic objects, cycles, hidden/symbol keys and extra array
+properties fail. DAG aliases remain aliases in the snapshot; the input is not mutated or retained.
+Invalid extras fail with non-retryable `provider_error`, fixed message
+`Invalid … extraBody JSON: expected a JSON object`, and no HTTP request. Messages never echo values.
+The composed request still passes final `Schema.Json` admission after lone-surrogate rewriting.
+This is not a guarantee against Proxy traps. Gateway routing projects its declared `order`, `only`
+and `sort` fields into JSON; canonical headers and provider identity stay host-owned.
+
+### OpenAI Realtime tool JSON
+
+Public `OpenAiRealtimeFunctionTool.parameters` and `openAiRealtimeToolParameters(parameters: Schema.Json)`
+now require admitted JSON. Non-JSON advertisement fails `VoiceToolBridgeError` before transport:
+synchronous `toOpenAiRealtimeTool`, `makeOpenAiRealtimeSessionConfig`, and
+`openAiRealtimeSessionConfigFromVoice` throw; `toOpenAiRealtimeToolEffect`,
+`makeOpenAiRealtimeSessionConfigEffect`, and `openAiRealtimeSessionConfigFromVoiceEffect` fail in the
+Effect error channel. Unexpected mapper defects (for example throwing getters) remain defects via
+`Effect.suspend` / `Result`, not `VoiceToolBridgeError`.
+
+Union-root lowering uses `Map<string, Schema.Json>` plus `Object.fromEntries` so own `__proto__` /
+`constructor` fields merge (first-seen / string-enum union) instead of prototype assignment or
+inherited `constructor` masquerading as Schema.Json. Required intersection, empty-required omission,
+and object-root identity are unchanged.
+
 ## Provider failures and retries
 
 Provider adapters classify safe failure metadata at the boundary. The loop owns bounded retry
@@ -464,7 +615,7 @@ HITL is protocol-level, not UI-level:
   `streamToolApprovalResponseEventStream`.
 - Denials become model-visible `ToolResult` messages with `isError = true`.
 - Use `makeQuestionToolModule` to expose the package-owned `question` tool; answers resume as structured tool results and model-visible text with selected labels. The loop intercepts questions only when the tool is enabled in `tools`; omitted questions return an unavailable result without HITL or executor dispatch, even if a provider emits one.
-- Use `questionResponseStructuredContent` / `plainHitlResponse` before storing durable HITL payloads that must be plain JSON.
+- Use `questionResponseStructuredContent` / `plainHitlResponse` before storing durable HITL payloads that must be plain JSON. `PlainHitlResponse` is a `Data.taggedEnum` value (`QuestionResponse` / `ToolApprovalResponse`); the helpers omit absent optionals then call those constructors (`_tag` last, plain objects, not Schema classes).
 - Use `toolRunsFromHitlRequests` to hydrate paused UI state from `AgentAwaitingInput.requests`.
 - Use `hitlResponseEvent` when a client needs optimistic approval/question UI updates before resumed stream events arrive.
 - Approval is a host-enforced per-call gate for normal tools, not a model-callable permission tool or persisted allow-always system.
@@ -510,6 +661,20 @@ request matching. Hosts expose the run endpoints and validate access/response id
 
 ## Voice
 
+`VoiceSession.layer` (`@yolk-sdk/agent/voice`) composes a supplied `VoiceTransport` layer,
+`VoiceController`, and an optional `VoiceEventOutbox`. Configured `eventLog` captures events without
+an external stream consumer; omitting it never captures an ambient outbox. The returned event stream
+has one queue consumer and is not a broadcast subscription. Without a consumer, events accumulate
+in memory; hosts should normally drain it. Seeds run during acquisition.
+
+Breaking 0.x migration: `makeVoiceController` no longer takes `options.transport`; provide
+`VoiceTransport` with `Effect.provideService`, or use `VoiceSession.layer`.
+`webRtcVoiceTransportLayer` (`voice/browser`) and `webSocketVoiceTransportLayer` (`voice`) acquire
+scoped transports. `Layer.succeed(VoiceTransport, transport)` injects a caller-owned value; it does
+not allocate/finalize it or guarantee fresh resources. Keep the entire usage effect inside a
+provided layer, or use `Layer.buildWithScope` when an explicit session scope owns its lifetime.
+`useYolkVoice` builds each attempt in that attempt's scope and retains stop/unmount cleanup.
+
 Voice is a first-class modality: browser WebRTC transport, client controller, server tool
 handler, approval HITL, transcript projection, and one-shot TTS/STT contracts.
 
@@ -535,6 +700,17 @@ handler, approval HITL, transcript projection, and one-shot TTS/STT contracts.
   `VoiceSpeechRequest.instructions` steers delivery style only, and
   provider 429s (rate limit or exhausted credits) surface as `VoiceSpeechError` code
   `rate_limited` so hosts can distinguish quota from outage.
+- Browser WebRTC hosts that implement `WebRtcPeerConnectionLike`
+  (`@yolk-sdk/agent/voice/browser`) treat `addTrack(track, stream)` as a void command. The
+  transport discards the DOM `RTCRtpSender`. Hosts and fakes must not read a sender from this
+  capability. Real `RTCPeerConnection.addTrack` remains assignable.
+- `protocolToolCallFromVoice` still returns `ToolCall`. Voice raw argument JSON admits finite
+  JSON (`Schema.Json`). Actual `null`, `false`, and `0` still admit as those values. Non-JSON
+  and non-finite numbers fail admission: raw text `1e999` projects as the argument string
+  `'1e999'`, and `decideVoiceToolCall` approval display params are `{ argumentsJson: '1e999' }`
+  (not `Infinity`; do not demonstrate with `JSON.stringify(Infinity)`, which is `null`). Nested
+  overflow such as `{"n":1e999}` takes the same mapper-specific fallbacks. Approval identifiers,
+  gates, deny, and execution schema validation are unchanged.
 
 ## Subagents
 
@@ -606,10 +782,12 @@ Without a host, definitions, approval ids, and inline behavior are unchanged.
   replays cannot replace accepted calls or receipts, including across turn cleanup and hydration.
 - Activated definitions are unsupported in voice/realtime, including foreground envelope calls.
   Resolve voice toolsets without a background host. Synchronous realtime tool/config mappers throw
-  `VoiceToolBridgeError`; use `toOpenAiRealtimeToolEffect`, `makeOpenAiRealtimeSessionConfigEffect`,
-  or `openAiRealtimeSessionConfigFromVoiceEffect` inside Effect programs to catch that typed error.
-  Voice handlers deny before approval matching, and the low-level bridge
-  rejects activated registry dispatch before validation, inline execution, or admission.
+  `VoiceToolBridgeError` for unsupported activation **and** for non-JSON tool `parameters`; use
+  `toOpenAiRealtimeToolEffect`, `makeOpenAiRealtimeSessionConfigEffect`, or
+  `openAiRealtimeSessionConfigFromVoiceEffect` inside Effect programs to catch that typed error.
+  Unexpected mapper defects stay defects, not `VoiceToolBridgeError`. Voice handlers deny before
+  approval matching, and the low-level bridge rejects activated registry dispatch before validation,
+  inline execution, or admission.
 - Raw `ToolRegistration` objects need a side-effect-free `validate` to activate; the loop-owned
   `question` and `subagent` tools cannot activate (subagents keep `makeSubagentAcceptedToolResult`).
 - Manual approval fences the whole batch; activated calls bind the approval `requestId` to the tool
@@ -627,6 +805,13 @@ data. `makeTool` converts these failures into `ToolResult.isError = true` so the
 see the message and continue. The result includes structured content with `type`, `tool`,
 `reason`, `message`, and optional `details` for UI/runtime handling.
 
+Optional `makeTool({ invalidParamsMessage })` receives the `Schema.SchemaError` produced by
+`Schema.decodeUnknownEffect` on `parameters` (validate and execute). The decode error is passed
+through unwrapped. Default text is `Invalid ${name} arguments: ${String(error)}`, which keeps the
+`SchemaError(...)` wrapper. In Effect rc.115, `SchemaError` extends native `Error`, but the
+wrapper remains part of this tool-message contract; do not default to `.message`.
+Existing `(error: unknown) => string` callbacks remain assignable.
+
 Thrown `ToolError`s become model-visible failed tool results plus `ToolExecutionError` events,
 so keep messages safe and non-secret. Reserve stream failure for provider/runtime defects,
 aborts, and implementation bugs outside typed tool execution.

package/dist/client/attachments.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"attachments.d.mts","names":[],"sources":["../../src/client/attachments.ts"],"mappings":";;;cA6Ca,YAAA,GAAgB,IAAA,EAAM,IAAA,KAAI,MAAA,CAAA,MAAA,SAAA,KAAA;AAAA,cAW1B,wBAAA,GACX,IAAA,EAAM,IAAA,EACN,OAAA;EAAA,SACW,KAAA;AAAA,MACV,MAAA,CAAA,MAAA,oCAAA,YAAA,cAAA,KAAA"}
+{"version":3,"file":"attachments.d.mts","names":[],"sources":["../../src/client/attachments.ts"],"mappings":";;;cAmDa,YAAA,GAAgB,IAAA,EAAM,IAAA,KAAI,MAAA,CAAA,MAAA,SAAA,KAAA;AAAA,cAW1B,wBAAA,GACX,IAAA,EAAM,IAAA,EACN,OAAA;EAAA,SACW,KAAA;AAAA,MACV,MAAA,CAAA,MAAA,oCAAA,YAAA,cAAA,KAAA"}

package/dist/client/attachments.mjs

@@ -1,4 +1,4 @@
-import { Effect, Result } from "effect";
+import { Effect, Predicate, Result } from "effect";
 import { documentPartFromText, inferTextDocumentMimeType } from "@yolk-sdk/agent/protocol";
 //#region src/client/attachments.ts
 const couldNotReadTextError = () => /* @__PURE__ */ new Error("Could not read text");
@@ -19,7 +19,7 @@ const textFromFileReaderEffect = (blob) => Effect.callback((resume) => {
 	};
 	const handleLoad = () => {
 		removeListeners();
-		if (typeof reader.result === "string") {
+		if (Predicate.isString(reader.result)) {
 			resume(Effect.succeed(reader.result));
 			return;
 		}
@@ -33,7 +33,7 @@ const textFromFileReaderEffect = (blob) => Effect.callback((resume) => {
 	return Effect.sync(removeListeners);
 });
 const textFromBlob = (blob) => {
-	if (typeof blob.text === "function") return Effect.tryPromise({
+	if (Predicate.isFunction(blob.text)) return Effect.tryPromise({
 		try: () => blob.text(),
 		catch: couldNotReadTextError
 	});

package/dist/client/attachments.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"attachments.mjs","names":[],"sources":["../../src/client/attachments.ts"],"sourcesContent":["import { Effect, Result } from 'effect'\nimport { documentPartFromText, inferTextDocumentMimeType } from '@yolk-sdk/agent/protocol'\n\nconst couldNotReadTextError = () => new Error('Could not read text')\n\nconst textFromFileReaderEffect = (blob: Blob) =>\n  Effect.callback<string, Error>(resume => {\n    if (typeof FileReader === 'undefined') {\n      resume(Effect.fail(couldNotReadTextError()))\n      return Effect.void\n    }\n\n    const reader = new FileReader()\n    const removeListeners = () => {\n      reader.removeEventListener('load', handleLoad)\n      reader.removeEventListener('error', handleError)\n      reader.removeEventListener('abort', handleError)\n    }\n    const fail = () => {\n      removeListeners()\n      resume(Effect.fail(couldNotReadTextError()))\n    }\n    const handleLoad = () => {\n      removeListeners()\n\n      if (typeof reader.result === 'string') {\n        resume(Effect.succeed(reader.result))\n        return\n      }\n\n      resume(Effect.fail(couldNotReadTextError()))\n    }\n    const handleError = () => fail()\n\n    reader.addEventListener('load', handleLoad)\n    reader.addEventListener('error', handleError)\n    reader.addEventListener('abort', handleError)\n\n    if (Result.isFailure(Result.try(() => reader.readAsText(blob)))) {\n      fail()\n    }\n\n    return Effect.sync(removeListeners)\n  })\n\nexport const textFromBlob = (blob: Blob) => {\n  if (typeof blob.text === 'function') {\n    return Effect.tryPromise({\n      try: () => blob.text(),\n      catch: couldNotReadTextError\n    })\n  }\n\n  return textFromFileReaderEffect(blob)\n}\n\nexport const documentPartFromTextFile = (\n  file: File,\n  options?: {\n    readonly title?: string\n  }\n) =>\n  Effect.gen(function* () {\n    const mimeType = inferTextDocumentMimeType({\n      filename: file.name,\n      mimeType: file.type\n    })\n\n    if (mimeType === undefined) return undefined\n\n    const text = yield* textFromBlob(file)\n\n    return documentPartFromText({\n      text,\n      filename: file.name,\n      mimeType,\n      title: options?.title\n    })\n  })\n"],"mappings":";;;AAGA,MAAM,8CAA8B,IAAI,MAAM,qBAAqB;AAEnE,MAAM,4BAA4B,SAChC,OAAO,UAAwB,WAAU;CACvC,IAAI,OAAO,eAAe,aAAa;EACrC,OAAO,OAAO,KAAK,sBAAsB,CAAC,CAAC;EAC3C,OAAO,OAAO;CAChB;CAEA,MAAM,SAAS,IAAI,WAAW;CAC9B,MAAM,wBAAwB;EAC5B,OAAO,oBAAoB,QAAQ,UAAU;EAC7C,OAAO,oBAAoB,SAAS,WAAW;EAC/C,OAAO,oBAAoB,SAAS,WAAW;CACjD;CACA,MAAM,aAAa;EACjB,gBAAgB;EAChB,OAAO,OAAO,KAAK,sBAAsB,CAAC,CAAC;CAC7C;CACA,MAAM,mBAAmB;EACvB,gBAAgB;EAEhB,IAAI,OAAO,OAAO,WAAW,UAAU;GACrC,OAAO,OAAO,QAAQ,OAAO,MAAM,CAAC;GACpC;EACF;EAEA,OAAO,OAAO,KAAK,sBAAsB,CAAC,CAAC;CAC7C;CACA,MAAM,oBAAoB,KAAK;CAE/B,OAAO,iBAAiB,QAAQ,UAAU;CAC1C,OAAO,iBAAiB,SAAS,WAAW;CAC5C,OAAO,iBAAiB,SAAS,WAAW;CAE5C,IAAI,OAAO,UAAU,OAAO,UAAU,OAAO,WAAW,IAAI,CAAC,CAAC,GAC5D,KAAK;CAGP,OAAO,OAAO,KAAK,eAAe;AACpC,CAAC;AAEH,MAAa,gBAAgB,SAAe;CAC1C,IAAI,OAAO,KAAK,SAAS,YACvB,OAAO,OAAO,WAAW;EACvB,WAAW,KAAK,KAAK;EACrB,OAAO;CACT,CAAC;CAGH,OAAO,yBAAyB,IAAI;AACtC;AAEA,MAAa,4BACX,MACA,YAIA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,0BAA0B;EACzC,UAAU,KAAK;EACf,UAAU,KAAK;CACjB,CAAC;CAED,IAAI,aAAa,KAAA,GAAW,OAAO,KAAA;CAInC,OAAO,qBAAqB;EAC1B,MAAA,OAHkB,aAAa,IAAI;EAInC,UAAU,KAAK;EACf;EACA,OAAO,SAAS;CAClB,CAAC;AACH,CAAC"}
+{"version":3,"file":"attachments.mjs","names":[],"sources":["../../src/client/attachments.ts"],"sourcesContent":["import { Effect, Predicate, Result } from 'effect'\nimport { documentPartFromText, inferTextDocumentMimeType } from '@yolk-sdk/agent/protocol'\n\nconst couldNotReadTextError = () => new Error('Could not read text')\n\nconst textFromFileReaderEffect = (blob: Blob) =>\n  Effect.callback<string, Error>(resume => {\n    if (typeof FileReader === 'undefined') {\n      resume(Effect.fail(couldNotReadTextError()))\n\n      return Effect.void\n    }\n\n    const reader = new FileReader()\n\n    const removeListeners = () => {\n      reader.removeEventListener('load', handleLoad)\n      reader.removeEventListener('error', handleError)\n      reader.removeEventListener('abort', handleError)\n    }\n\n    const fail = () => {\n      removeListeners()\n      resume(Effect.fail(couldNotReadTextError()))\n    }\n\n    const handleLoad = () => {\n      removeListeners()\n\n      if (Predicate.isString(reader.result)) {\n        resume(Effect.succeed(reader.result))\n\n        return\n      }\n\n      resume(Effect.fail(couldNotReadTextError()))\n    }\n\n    const handleError = () => fail()\n\n    reader.addEventListener('load', handleLoad)\n    reader.addEventListener('error', handleError)\n    reader.addEventListener('abort', handleError)\n\n    if (Result.isFailure(Result.try(() => reader.readAsText(blob)))) {\n      fail()\n    }\n\n    return Effect.sync(removeListeners)\n  })\n\nexport const textFromBlob = (blob: Blob) => {\n  if (Predicate.isFunction(blob.text)) {\n    return Effect.tryPromise({\n      try: () => blob.text(),\n      catch: couldNotReadTextError\n    })\n  }\n\n  return textFromFileReaderEffect(blob)\n}\n\nexport const documentPartFromTextFile = (\n  file: File,\n  options?: {\n    readonly title?: string\n  }\n) =>\n  Effect.gen(function* () {\n    const mimeType = inferTextDocumentMimeType({\n      filename: file.name,\n      mimeType: file.type\n    })\n\n    if (mimeType === undefined) return undefined\n\n    const text = yield* textFromBlob(file)\n\n    return documentPartFromText({\n      text,\n      filename: file.name,\n      mimeType,\n      title: options?.title\n    })\n  })\n"],"mappings":";;;AAGA,MAAM,8CAA8B,IAAI,MAAM,qBAAqB;AAEnE,MAAM,4BAA4B,SAChC,OAAO,UAAwB,WAAU;CACvC,IAAI,OAAO,eAAe,aAAa;EACrC,OAAO,OAAO,KAAK,sBAAsB,CAAC,CAAC;EAE3C,OAAO,OAAO;CAChB;CAEA,MAAM,SAAS,IAAI,WAAW;CAE9B,MAAM,wBAAwB;EAC5B,OAAO,oBAAoB,QAAQ,UAAU;EAC7C,OAAO,oBAAoB,SAAS,WAAW;EAC/C,OAAO,oBAAoB,SAAS,WAAW;CACjD;CAEA,MAAM,aAAa;EACjB,gBAAgB;EAChB,OAAO,OAAO,KAAK,sBAAsB,CAAC,CAAC;CAC7C;CAEA,MAAM,mBAAmB;EACvB,gBAAgB;EAEhB,IAAI,UAAU,SAAS,OAAO,MAAM,GAAG;GACrC,OAAO,OAAO,QAAQ,OAAO,MAAM,CAAC;GAEpC;EACF;EAEA,OAAO,OAAO,KAAK,sBAAsB,CAAC,CAAC;CAC7C;CAEA,MAAM,oBAAoB,KAAK;CAE/B,OAAO,iBAAiB,QAAQ,UAAU;CAC1C,OAAO,iBAAiB,SAAS,WAAW;CAC5C,OAAO,iBAAiB,SAAS,WAAW;CAE5C,IAAI,OAAO,UAAU,OAAO,UAAU,OAAO,WAAW,IAAI,CAAC,CAAC,GAC5D,KAAK;CAGP,OAAO,OAAO,KAAK,eAAe;AACpC,CAAC;AAEH,MAAa,gBAAgB,SAAe;CAC1C,IAAI,UAAU,WAAW,KAAK,IAAI,GAChC,OAAO,OAAO,WAAW;EACvB,WAAW,KAAK,KAAK;EACrB,OAAO;CACT,CAAC;CAGH,OAAO,yBAAyB,IAAI;AACtC;AAEA,MAAa,4BACX,MACA,YAIA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,0BAA0B;EACzC,UAAU,KAAK;EACf,UAAU,KAAK;CACjB,CAAC;CAED,IAAI,aAAa,KAAA,GAAW,OAAO,KAAA;CAInC,OAAO,qBAAqB;EAC1B,MAAA,OAHkB,aAAa,IAAI;EAInC,UAAU,KAAK;EACf;EACA,OAAO,SAAS;CAClB,CAAC;AACH,CAAC"}

package/dist/client/state.d.mts

@@ -1,3 +1,4 @@
+import { Data } from "effect";
 import { AgentError, AgentEvent, AgentMessage, AgentRetry, HitlRequest, QuestionRequest, QuestionResponse, ToolApprovalRequest, ToolCall, ToolResult, UserMessage } from "@yolk-sdk/agent/protocol";
 
 //#region src/client/state.d.ts
@@ -55,6 +56,283 @@ type AgentToolRun = {
   readonly call: ToolCall;
   readonly result: ToolResult;
 };
+declare const AgentToolRun: {
+  readonly InputStreaming: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "InputStreaming";
+    readonly id: string;
+    readonly name?: string;
+    readonly input: string;
+  }, "_tag">;
+  readonly InputReady: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "InputReady";
+    readonly call: ToolCall;
+  }, "_tag">;
+  readonly ApprovalRequested: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ApprovalRequested";
+    readonly call: ToolCall;
+    readonly request?: ToolApprovalRequest;
+  }, "_tag">;
+  readonly Denied: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Denied";
+    readonly toolCallId: string;
+    readonly reason: string;
+  }, "_tag">;
+  readonly QuestionRequested: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "QuestionRequested";
+    readonly request: QuestionRequest;
+  }, "_tag">;
+  readonly QuestionAnswered: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "QuestionAnswered";
+    readonly response: QuestionResponse;
+    readonly request?: QuestionRequest;
+  }, "_tag">;
+  readonly QuestionCancelled: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "QuestionCancelled";
+    readonly response: QuestionResponse;
+    readonly request?: QuestionRequest;
+  }, "_tag">;
+  readonly Executing: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Executing";
+    readonly call: ToolCall;
+    readonly startedAtMs: number;
+  }, "_tag">;
+  readonly Completed: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Completed";
+    readonly call: ToolCall;
+    readonly result: ToolResult;
+    readonly startedAtMs: number;
+    readonly endedAtMs: number;
+  }, "_tag">;
+  readonly Accepted: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Accepted";
+    readonly call: ToolCall;
+    readonly result: ToolResult;
+    readonly startedAtMs: number;
+    readonly endedAtMs: number;
+  }, "_tag">;
+  readonly Errored: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Errored";
+    readonly call: ToolCall;
+    readonly message: string;
+    readonly endedAtMs: number;
+  }, "_tag">;
+  readonly ProviderCompleted: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ProviderCompleted";
+    readonly call: ToolCall;
+    readonly result: ToolResult;
+  }, "_tag">;
+  readonly $is: <Tag extends "InputStreaming" | "InputReady" | "ApprovalRequested" | "Denied" | "QuestionRequested" | "QuestionAnswered" | "QuestionCancelled" | "Executing" | "Completed" | "Accepted" | "Errored" | "ProviderCompleted">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "InputStreaming";
+    readonly id: string;
+    readonly name?: string;
+    readonly input: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "InputReady";
+    readonly call: ToolCall;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ApprovalRequested";
+    readonly call: ToolCall;
+    readonly request?: ToolApprovalRequest;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Denied";
+    readonly toolCallId: string;
+    readonly reason: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "QuestionRequested";
+    readonly request: QuestionRequest;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "QuestionAnswered";
+    readonly response: QuestionResponse;
+    readonly request?: QuestionRequest;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "QuestionCancelled";
+    readonly response: QuestionResponse;
+    readonly request?: QuestionRequest;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Executing";
+    readonly call: ToolCall;
+    readonly startedAtMs: number;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Completed";
+    readonly call: ToolCall;
+    readonly result: ToolResult;
+    readonly startedAtMs: number;
+    readonly endedAtMs: number;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Accepted";
+    readonly call: ToolCall;
+    readonly result: ToolResult;
+    readonly startedAtMs: number;
+    readonly endedAtMs: number;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Errored";
+    readonly call: ToolCall;
+    readonly message: string;
+    readonly endedAtMs: number;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ProviderCompleted";
+    readonly call: ToolCall;
+    readonly result: ToolResult;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly InputStreaming: (args: {
+        readonly _tag: "InputStreaming";
+        readonly id: string;
+        readonly name?: string;
+        readonly input: string;
+      }) => any;
+      readonly InputReady: (args: {
+        readonly _tag: "InputReady";
+        readonly call: ToolCall;
+      }) => any;
+      readonly ApprovalRequested: (args: {
+        readonly _tag: "ApprovalRequested";
+        readonly call: ToolCall;
+        readonly request?: ToolApprovalRequest;
+      }) => any;
+      readonly Denied: (args: {
+        readonly _tag: "Denied";
+        readonly toolCallId: string;
+        readonly reason: string;
+      }) => any;
+      readonly QuestionRequested: (args: {
+        readonly _tag: "QuestionRequested";
+        readonly request: QuestionRequest;
+      }) => any;
+      readonly QuestionAnswered: (args: {
+        readonly _tag: "QuestionAnswered";
+        readonly response: QuestionResponse;
+        readonly request?: QuestionRequest;
+      }) => any;
+      readonly QuestionCancelled: (args: {
+        readonly _tag: "QuestionCancelled";
+        readonly response: QuestionResponse;
+        readonly request?: QuestionRequest;
+      }) => any;
+      readonly Executing: (args: {
+        readonly _tag: "Executing";
+        readonly call: ToolCall;
+        readonly startedAtMs: number;
+      }) => any;
+      readonly Completed: (args: {
+        readonly _tag: "Completed";
+        readonly call: ToolCall;
+        readonly result: ToolResult;
+        readonly startedAtMs: number;
+        readonly endedAtMs: number;
+      }) => any;
+      readonly Accepted: (args: {
+        readonly _tag: "Accepted";
+        readonly call: ToolCall;
+        readonly result: ToolResult;
+        readonly startedAtMs: number;
+        readonly endedAtMs: number;
+      }) => any;
+      readonly Errored: (args: {
+        readonly _tag: "Errored";
+        readonly call: ToolCall;
+        readonly message: string;
+        readonly endedAtMs: number;
+      }) => any;
+      readonly ProviderCompleted: (args: {
+        readonly _tag: "ProviderCompleted";
+        readonly call: ToolCall;
+        readonly result: ToolResult;
+      }) => any;
+    }>(cases: Cases): (value: AgentToolRun) => import("effect/Unify").Unify<ReturnType<Cases["InputStreaming" | "InputReady" | "ApprovalRequested" | "Denied" | "QuestionRequested" | "QuestionAnswered" | "QuestionCancelled" | "Executing" | "Completed" | "Accepted" | "Errored" | "ProviderCompleted"]>>;
+    <Cases extends {
+      readonly InputStreaming: (args: {
+        readonly _tag: "InputStreaming";
+        readonly id: string;
+        readonly name?: string;
+        readonly input: string;
+      }) => any;
+      readonly InputReady: (args: {
+        readonly _tag: "InputReady";
+        readonly call: ToolCall;
+      }) => any;
+      readonly ApprovalRequested: (args: {
+        readonly _tag: "ApprovalRequested";
+        readonly call: ToolCall;
+        readonly request?: ToolApprovalRequest;
+      }) => any;
+      readonly Denied: (args: {
+        readonly _tag: "Denied";
+        readonly toolCallId: string;
+        readonly reason: string;
+      }) => any;
+      readonly QuestionRequested: (args: {
+        readonly _tag: "QuestionRequested";
+        readonly request: QuestionRequest;
+      }) => any;
+      readonly QuestionAnswered: (args: {
+        readonly _tag: "QuestionAnswered";
+        readonly response: QuestionResponse;
+        readonly request?: QuestionRequest;
+      }) => any;
+      readonly QuestionCancelled: (args: {
+        readonly _tag: "QuestionCancelled";
+        readonly response: QuestionResponse;
+        readonly request?: QuestionRequest;
+      }) => any;
+      readonly Executing: (args: {
+        readonly _tag: "Executing";
+        readonly call: ToolCall;
+        readonly startedAtMs: number;
+      }) => any;
+      readonly Completed: (args: {
+        readonly _tag: "Completed";
+        readonly call: ToolCall;
+        readonly result: ToolResult;
+        readonly startedAtMs: number;
+        readonly endedAtMs: number;
+      }) => any;
+      readonly Accepted: (args: {
+        readonly _tag: "Accepted";
+        readonly call: ToolCall;
+        readonly result: ToolResult;
+        readonly startedAtMs: number;
+        readonly endedAtMs: number;
+      }) => any;
+      readonly Errored: (args: {
+        readonly _tag: "Errored";
+        readonly call: ToolCall;
+        readonly message: string;
+        readonly endedAtMs: number;
+      }) => any;
+      readonly ProviderCompleted: (args: {
+        readonly _tag: "ProviderCompleted";
+        readonly call: ToolCall;
+        readonly result: ToolResult;
+      }) => any;
+    }>(value: AgentToolRun, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["InputStreaming" | "InputReady" | "ApprovalRequested" | "Denied" | "QuestionRequested" | "QuestionAnswered" | "QuestionCancelled" | "Executing" | "Completed" | "Accepted" | "Errored" | "ProviderCompleted"]>>;
+  };
+};
 type AgentClientState = {
   readonly status: AgentRunStatus;
   readonly messages: ReadonlyArray<AgentMessage>;