@codeworksh/plugin 0.0.1-dev.20260922103030

package/shell-CZ6Y4lNU.d.mts

@@ -0,0 +1,109 @@
+import { Context, Effect, Schema, Stream } from "effect";
+//#region src/sandbox/shell.d.ts
+declare const ShellError_base: Schema.Class<ShellError, Schema.TaggedStruct<"ShellError", {
+  readonly command: Schema.String;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The pluggable execution contract. Local sandboxes usually get a Shell through
+ * just-bash over the local `Local.Vfs`; remote sandboxes provide their own
+ * native Shell. Either way the rest of the harness depends only on this service
+ * tag.
+ */
+declare class ShellError extends ShellError_base {}
+interface ExecResult {
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly exitCode: number;
+}
+/**
+ * One options shape for every entry point. `cwd` is the operation-level
+ * override: it wins over the mount's working directory, and a relative value
+ * resolves against it. Neither mutates shared state, so concurrent commands in
+ * one mount can run in different directories.
+ */
+interface ShellOptions {
+  readonly env?: Record<string, string>;
+  readonly cwd?: string;
+}
+/**
+ * A streamed chunk of command output, terminated by a single `exit` carrying the
+ * exit code. (A backend-level mirror of the tool layer's event; kept here so
+ * `sandbox/` does not depend on `tool/`.)
+ */
+type ExecChunk = {
+  readonly _tag: "stdout";
+  readonly bytes: Uint8Array;
+} | {
+  readonly _tag: "stderr";
+  readonly bytes: Uint8Array;
+} | {
+  readonly _tag: "exit";
+  readonly exitCode: number;
+};
+/**
+ * The command-execution capability a sandbox exposes. For an in-process
+ * backend this is just-bash; for a remote backend it is the sandbox's own
+ * shell. The {@link Shell} service tag carries this interface.
+ */
+interface ISandboxExe {
+  readonly exec: (command: string, options?: ShellOptions) => Effect.Effect<ExecResult, ShellError>;
+  /**
+   * Run a program with an explicit argument vector, bypassing shell word
+   * splitting. Callers that build commands from untrusted values — branch
+   * names, file paths — must use this instead of interpolating into
+   * {@link exec}, where a space or `$(…)` would change what runs.
+   *
+   * Backends whose transport only accepts a string quote the vector with
+   * {@link quote}; backends that spawn directly pass it through untouched.
+   */
+  readonly execArgv: (argv: ReadonlyArray<string>, options?: ShellOptions) => Effect.Effect<ExecResult, ShellError>;
+  /**
+   * Optional streaming output: stdout/stderr chunks then a terminal `exit`.
+   * Backends that can stream (e.g. Vercel) implement it; `ToolShell.fromSandboxShell`
+   * bridges it to `ToolShell.stream` so the bash tool streams over them too.
+   */
+  readonly stream?: (command: string, options?: ShellOptions) => Stream.Stream<ExecChunk, ShellError>;
+}
+type MountFactory = (cwd: string) => ISandboxExe;
+declare const perMount: (transport: ISandboxExe, make: MountFactory) => ISandboxExe;
+/**
+ * POSIX single-quote escaping: wrap in `'…'` and rewrite each embedded quote as
+ * `'\''`. Everything inside single quotes is literal to the shell, so this is
+ * safe for arbitrary bytes.
+ */
+declare const quote: (value: string) => string;
+/** Render an argument vector as one shell-safe command string. */
+declare const quoteArgv: (argv: ReadonlyArray<string>) => string;
+/**
+ * Resolve a per-command cwd against the sandbox cwd. Passing a relative cwd
+ * straight to a host or remote process API would otherwise resolve it against
+ * that API's own default, which need not be the filesystem's configured cwd.
+ */
+declare const resolveCwd: (base: string | undefined, cwd: string | undefined) => string | undefined;
+/**
+ * Complete a string-only backend: `execArgv` quotes the vector and runs it
+ * through `exec`. Backends that spawn a real argument vector (Vercel) implement
+ * `execArgv` themselves instead, so the args never meet a shell parser at all.
+ *
+ * `cwd` rides the options rather than a `cd <dir> && …` prefix. Every backend
+ * we wrap takes a working directory natively, and the prefix form cannot tell a
+ * failed `cd` from a failed command — both arrive as one exit code.
+ */
+declare const fromExec: (backend: Omit<ISandboxExe, "execArgv">) => ISandboxExe;
+/**
+ * Bind a cwd-neutral backend to one mount's working directory.
+ *
+ * The transport is shared between mounts and must stay rooted at the namespace
+ * root, so the directory cannot live inside it: two mounts at different
+ * directories would otherwise see each other's. This wrapper is per mount, and
+ * an operation-level `cwd` still wins — resolved against the mount's, so a
+ * relative one means what it reads like.
+ */
+declare const withCwd: (backend: ISandboxExe, cwd: string) => ISandboxExe;
+declare const Shell_base: Context.ServiceClass<Shell, "@codeworksh/plugin/sandbox/shell", ISandboxExe>;
+/** Execution service — the live {@link ISandboxExe} for the active sandbox. */
+declare class Shell extends Shell_base {}
+//#endregion
+export { ShellError as a, perMount as c, resolveCwd as d, withCwd as f, Shell as i, quote as l, ExecResult as n, ShellOptions as o, ISandboxExe as r, fromExec as s, ExecChunk as t, quoteArgv as u };
+//# sourceMappingURL=shell-CZ6Y4lNU.d.mts.map

package/space-CR-9UxdT.d.mts

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+declare namespace space_d_exports {
+  export { ID, Info, Kind, space_d_exports as SpaceSchema, Status };
+}
+declare const ID: Schema.brand<Schema.String, "Space.ID">;
+type ID = typeof ID.Type;
+declare const Kind: Schema.Literals<readonly ["primary", "linked", "copy", "plain"]>;
+type Kind = typeof Kind.Type;
+declare const Status: Schema.Literals<readonly ["active", "archived"]>;
+type Status = typeof Status.Type;
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+  readonly id: Schema.brand<Schema.String, "Space.ID">;
+  readonly projectId: Schema.brand<Schema.String, "Project.ID">;
+  readonly location: Schema.brand<Schema.String, "AbsolutePath">;
+  readonly kind: Schema.Literals<readonly ["primary", "linked", "copy", "plain"]>;
+  readonly env: Schema.brand<Schema.String, "SandboxInstance.ID"> & {
+    local: string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+    create: () => string & import("effect/Brand").Brand<"SandboxInstance.ID">;
+  };
+  readonly status: Schema.Literals<readonly ["active", "archived"]>;
+}>, {}>;
+declare class Info extends Info_base {}
+//#endregion
+export { space_d_exports as a, Status as i, Info as n, Kind as r, ID as t };
+//# sourceMappingURL=space-CR-9UxdT.d.mts.map

package/space.d.mts

@@ -0,0 +1,2 @@
+import { a as space_d_exports, i as Status, n as Info, r as Kind, t as ID } from "./space-CR-9UxdT.mjs";
+export { ID, Info, Kind, space_d_exports as SpaceSchema, Status };

package/space.mjs

@@ -0,0 +1,33 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { AbsolutePath } from "./schema.mjs";
+import { ID as ID$1 } from "./project.mjs";
+import { ID as ID$2 } from "./sandbox/instance.mjs";
+import { Schema } from "effect";
+//#region src/space.ts
+var space_exports = /* @__PURE__ */ __exportAll({
+	ID: () => ID,
+	Info: () => Info,
+	Kind: () => Kind,
+	SpaceSchema: () => space_exports,
+	Status: () => Status
+});
+const ID = Schema.String.pipe(Schema.brand("Space.ID"));
+const Kind = Schema.Literals([
+	"primary",
+	"linked",
+	"copy",
+	"plain"
+]);
+const Status = Schema.Literals(["active", "archived"]);
+var Info = class extends Schema.Class("Space.Info")({
+	id: ID,
+	projectId: ID$1,
+	location: AbsolutePath,
+	kind: Kind,
+	env: ID$2,
+	status: Status
+}) {};
+//#endregion
+export { ID, Info, Kind, space_exports as SpaceSchema, Status };
+
+//# sourceMappingURL=space.mjs.map

package/space.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"space.mjs","names":["ProjectSchema.ID","SandboxInstance.ID"],"sources":["../../src/space.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport { ProjectSchema } from \"./project.ts\";\nimport { SandboxInstance } from \"./sandbox/instance.ts\";\nimport { AbsolutePath } from \"./schema.ts\";\n\n// hash(env, location) — no project component, so re-pointing a space to\n// another project never rewrites the key sessions reference.\nexport const ID = Schema.String.pipe(Schema.brand(\"Space.ID\"));\nexport type ID = typeof ID.Type;\n\n// primary: the main checkout (one per project+env); linked: a git worktree\n// sharing the primary's store; copy: another clone; plain: a non-git directory.\nexport const Kind = Schema.Literals([\"primary\", \"linked\", \"copy\", \"plain\"]);\nexport type Kind = typeof Kind.Type;\n\nexport const Status = Schema.Literals([\"active\", \"archived\"]);\nexport type Status = typeof Status.Type;\n\n// One directory in one env that belongs to a project; the unit sessions attach to.\nexport class Info extends Schema.Class<Info>(\"Space.Info\")({\n\tid: ID,\n\tprojectId: ProjectSchema.ID,\n\tlocation: AbsolutePath,\n\tkind: Kind,\n\tenv: SandboxInstance.ID,\n\tstatus: Status,\n}) {}\n\nexport * as SpaceSchema from \"./space.ts\";\n"],"mappings":";;;;;;;;;;;;;AAOA,MAAa,KAAK,OAAO,OAAO,KAAK,OAAO,MAAM,UAAU,CAAC;AAK7D,MAAa,OAAO,OAAO,SAAS;CAAC;CAAW;CAAU;CAAQ;AAAO,CAAC;AAG1E,MAAa,SAAS,OAAO,SAAS,CAAC,UAAU,UAAU,CAAC;AAI5D,IAAa,OAAb,cAA0B,OAAO,MAAY,YAAY,CAAC,CAAC;CAC1D,IAAI;CACJ,WAAWA;CACX,UAAU;CACV,MAAM;CACN,KAAKC;CACL,QAAQ;AACT,CAAC,CAAC,CAAC,CAAC"}

package/tool/error.d.mts

@@ -0,0 +1,2 @@
+import { t as ToolExecutionError } from "../error-ClDISWlT.mjs";
+export { ToolExecutionError };

package/tool/error.mjs

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+//#region src/tool/error.ts
+/** A typed wrapper for a tool failure crossing the heterogeneous registry boundary. */
+var ToolExecutionError = class extends Schema.TaggedError()("ToolExecutionError", {
+	toolName: Schema.String,
+	cause: Schema.Defect()
+}) {};
+//#endregion
+export { ToolExecutionError };
+
+//# sourceMappingURL=error.mjs.map

package/tool/error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.mjs","names":[],"sources":["../../../src/tool/error.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n/** A typed wrapper for a tool failure crossing the heterogeneous registry boundary. */\nexport class ToolExecutionError extends Schema.TaggedError<ToolExecutionError>()(\"ToolExecutionError\", {\n\ttoolName: Schema.String,\n\tcause: Schema.Defect(),\n}) {}\n"],"mappings":";;;AAGA,IAAa,qBAAb,cAAwC,OAAO,YAAgC,CAAC,CAAC,sBAAsB;CACtG,UAAU,OAAO;CACjB,OAAO,OAAO,OAAO;AACtB,CAAC,CAAC,CAAC,CAAC"}

package/tool/progress.d.mts

@@ -0,0 +1,2 @@
+import { _ as IToolProgress, b as make, v as ToolProgress, x as noop, y as ToolProgressPartial } from "../tool-DuYBgiJf.mjs";
+export { IToolProgress, ToolProgress, ToolProgressPartial, make, noop };

package/tool/progress.mjs

@@ -0,0 +1,11 @@
+import { Context, Effect, Layer } from "effect";
+//#region src/tool/progress.ts
+var ToolProgress = class extends Context.Service()("@codeworksh/plugin/tool/progress/ToolProgress") {};
+/** Build a `ToolProgress` Layer from a `report` implementation. */
+const make = (report) => Layer.succeed(ToolProgress, ToolProgress.of({ report }));
+/** Drops every update — the default until the executor wires a live event sink. */
+const noop = make(() => Effect.void);
+//#endregion
+export { ToolProgress, make, noop };
+
+//# sourceMappingURL=progress.mjs.map

package/tool/progress.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.mjs","names":[],"sources":["../../../src/tool/progress.ts"],"sourcesContent":["import { Context, Effect, Layer } from \"effect\";\nimport type { ModelContent } from \"../tool.ts\";\n\n/**\n * `ToolProgress` — the side-channel a long-running tool (e.g. streaming bash)\n * writes interim output to, instead of an `onUpdate` callback.\n *\n * Most tools never call `report` and keep a clean `Effect<Success, Failure>`\n * signature. Throttling / coalescing lives in the Layer (the live one routes to\n * the run's event PubSub, tagged with the active callID); the handler just\n * reports.\n */\n\n/** Mirror of aikit's `Message.ToolRunningPartial` (kept structural to stay decoupled). */\nexport interface ToolProgressPartial {\n\treadonly content?: ModelContent;\n\treadonly details?: unknown;\n}\n\nexport interface IToolProgress {\n\treadonly report: (partial: ToolProgressPartial) => Effect.Effect<void>;\n}\n\nexport class ToolProgress extends Context.Service<ToolProgress, IToolProgress>()(\n\t\"@codeworksh/plugin/tool/progress/ToolProgress\",\n) {}\n\n/** Build a `ToolProgress` Layer from a `report` implementation. */\nexport const make = (report: IToolProgress[\"report\"]): Layer.Layer<ToolProgress> =>\n\tLayer.succeed(ToolProgress, ToolProgress.of({ report }));\n\n/** Drops every update — the default until the executor wires a live event sink. */\nexport const noop: Layer.Layer<ToolProgress> = make(() => Effect.void);\n"],"mappings":";;AAuBA,IAAa,eAAb,cAAkC,QAAQ,QAAqC,CAAC,CAC/E,+CACD,CAAC,CAAC,CAAC;;AAGH,MAAa,QAAQ,WACpB,MAAM,QAAQ,cAAc,aAAa,GAAG,EAAE,OAAO,CAAC,CAAC;;AAGxD,MAAa,OAAkC,WAAW,OAAO,IAAI"}

package/tool-BoVqkYvL.d.mts

@@ -0,0 +1,287 @@
+import { a as RegisteredTool, i as ModelContent, t as AnyToolDef } from "./tool-DuYBgiJf.mjs";
+import { Effect, Schema } from "effect";
+declare namespace tool_d_exports {
+  export { HookReturn, ToolAddOptions, ToolAfter, ToolAfterFn, ToolAfterResult, ToolBefore, ToolBeforeFn, ToolBeforeResult, ToolDefPatch, ToolRegistration, ToolRegistry, ToolResultContent };
+}
+declare const ToolBefore: Schema.Struct<{
+  readonly callID: Schema.String;
+  readonly toolName: Schema.String;
+  readonly rawArgs: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly sessionId: Schema.brand<Schema.String, "Session.ID"> & {
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"Session.ID">;
+    create: () => string & import("effect/Brand").Brand<"Session.ID">;
+  };
+  readonly messageId: Schema.brand<Schema.String, "Message.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Message.ID">;
+    from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+  };
+  readonly params: Schema.Unknown;
+}>;
+type ToolBefore = typeof ToolBefore.Type;
+declare const ToolAfter: Schema.Struct<{
+  readonly callID: Schema.String;
+  readonly toolName: Schema.String;
+  readonly rawArgs: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly sessionId: Schema.brand<Schema.String, "Session.ID"> & {
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"Session.ID">;
+    create: () => string & import("effect/Brand").Brand<"Session.ID">;
+  };
+  readonly messageId: Schema.brand<Schema.String, "Message.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Message.ID">;
+    from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+  };
+  readonly params: Schema.Unknown;
+  readonly terminal: Schema.decodeTo<Schema.declare<{
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: false;
+    };
+    status: "completed";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  } | {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: true;
+    };
+    status: "error";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  } | {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: true;
+    };
+    status: "skipped";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  } | {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: true;
+    };
+    status: "aborted";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  }, {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: false;
+    };
+    status: "completed";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  } | {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: true;
+    };
+    status: "error";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  } | {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: true;
+    };
+    status: "skipped";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  } | {
+    addedToolNames?: string[];
+    arguments: Record<string, any>;
+    callID: string;
+    name: string;
+    namespace?: string;
+    result: {
+      content: ({
+        type: "text";
+        text: string;
+        textSignature?: string;
+      } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+      })[];
+      details?: any;
+      isError: true;
+    };
+    status: "aborted";
+    thoughtSignature?: string;
+    time: {
+      start: number;
+      end: number;
+    };
+    type: "toolCall";
+  }>, Schema.Unknown, never, never>;
+}>;
+type ToolAfter = typeof ToolAfter.Type;
+declare const ToolBeforeResult: Schema.Struct<{
+  readonly block: Schema.Boolean;
+  readonly reason: Schema.optional<Schema.String>;
+}>;
+type ToolBeforeResult = typeof ToolBeforeResult.Type;
+type ToolResultContent = ModelContent;
+interface ToolAfterResult {
+  readonly content?: ToolResultContent;
+  readonly details?: unknown;
+  readonly isError?: boolean;
+}
+type HookReturn<A> = A | void | Promise<A | void> | Effect.Effect<A | void, unknown>;
+type ToolBeforeFn = (call: ToolBefore) => HookReturn<ToolBeforeResult>;
+type ToolAfterFn = (call: ToolAfter) => HookReturn<ToolAfterResult>;
+interface ToolAddOptions {
+  readonly beforeToolCall?: ToolBeforeFn;
+  readonly afterToolCall?: ToolAfterFn;
+}
+interface ToolDefPatch {
+  readonly description?: string;
+  readonly label?: string;
+  readonly promptSnippet?: string;
+  readonly promptGuidelines?: ReadonlyArray<string>;
+}
+/**
+ * One frozen bucket entry: the winning tool for a name together with the hooks that
+ * `add` declared alongside it. Kept here rather than in the bucket implementation so
+ * the executor shares the contract without importing plugin assembly.
+ */
+interface ToolRegistration {
+  readonly tool: RegisteredTool;
+  readonly hooks: ToolAddOptions;
+}
+interface ToolRegistry {
+  readonly add: (tool: RegisteredTool, options?: ToolAddOptions) => void;
+  readonly update: (name: string, patch: ToolDefPatch) => void;
+  readonly list: () => ReadonlyArray<AnyToolDef>;
+  readonly get: (name: string) => AnyToolDef | undefined;
+  readonly has: (name: string) => boolean;
+}
+//#endregion
+export { ToolAfterResult as a, ToolBeforeResult as c, ToolRegistry as d, ToolResultContent as f, ToolAfterFn as i, ToolDefPatch as l, ToolAddOptions as n, ToolBefore as o, tool_d_exports as p, ToolAfter as r, ToolBeforeFn as s, HookReturn as t, ToolRegistration as u };
+//# sourceMappingURL=tool-BoVqkYvL.d.mts.map

package/tool-DuYBgiJf.d.mts

@@ -0,0 +1,142 @@
+import { t as ToolExecutionError } from "./error-ClDISWlT.mjs";
+import { Message } from "@codeworksh/aikit";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/tool/progress.d.ts
+/**
+ * `ToolProgress` — the side-channel a long-running tool (e.g. streaming bash)
+ * writes interim output to, instead of an `onUpdate` callback.
+ *
+ * Most tools never call `report` and keep a clean `Effect<Success, Failure>`
+ * signature. Throttling / coalescing lives in the Layer (the live one routes to
+ * the run's event PubSub, tagged with the active callID); the handler just
+ * reports.
+ */
+/** Mirror of aikit's `Message.ToolRunningPartial` (kept structural to stay decoupled). */
+interface ToolProgressPartial {
+  readonly content?: ModelContent;
+  readonly details?: unknown;
+}
+interface IToolProgress {
+  readonly report: (partial: ToolProgressPartial) => Effect.Effect<void>;
+}
+declare const ToolProgress_base: Context.ServiceClass<ToolProgress, "@codeworksh/plugin/tool/progress/ToolProgress", IToolProgress>;
+declare class ToolProgress extends ToolProgress_base {}
+/** Build a `ToolProgress` Layer from a `report` implementation. */
+declare const make$1: (report: IToolProgress["report"]) => Layer.Layer<ToolProgress>;
+/** Drops every update — the default until the executor wires a live event sink. */
+declare const noop: Layer.Layer<ToolProgress>;
+declare namespace tool_d_exports {
+  export { AnyToolDef, AnyToolImpl, Handler, ModelContent, RegisteredTool, ToolCallContext, ToolDef, ToolImpl, define, implement, make, provide, register, toAikitTool, toProviderJsonSchema };
+}
+/**
+ * The tool definition + handler model.
+ *
+ * A tool definition is pure, serializable data: name, description, and Effect
+ * Schema for parameters / success / failure. Execution is a separate `Handler`
+ * — an `Effect` whose capability dependencies (e.g. `ToolShell`) live in its
+ * requirements `R`, provided by a Layer at runtime. Separating the two is the
+ * main testing win: assert on the definition as plain data, and run the handler
+ * against a stub capability Layer.
+ *
+ * Effect Schema is the single source of truth. {@link toAikitTool} derives a
+ * provider-safe JSON Schema object for the aikit wire view; the harness
+ * decode/encodes arguments and results with Effect Schema natively (it does not
+ * use aikit's Typebox validators).
+ */
+/** What the model reads next turn (the `content` side of content/details). */
+type ModelContent = ReadonlyArray<Message.TextContent | Message.ImageContent>;
+/** Per-call metadata handed to a handler instead of positional args. */
+declare const ToolCallContext: Schema.Struct<{
+  readonly callID: Schema.String;
+  readonly toolName: Schema.String;
+  readonly rawArgs: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+type ToolCallContext = typeof ToolCallContext.Type;
+/**
+ * A pure tool definition. Parametrised over the *schema* instances so the
+ * decoded parameter/success/failure types can be recovered via `["Type"]`.
+ */
+interface ToolDef<Name extends string = string, Params extends Schema.Top = Schema.Top, Success extends Schema.Top = Schema.Top, Failure extends Schema.Top = Schema.Top> {
+  readonly name: Name;
+  readonly description: string;
+  /** Human-readable display label (kept from the previous `AgentTool`). */
+  readonly label?: string;
+  /**
+   * A short one-line summary for compact tool listings (e.g. a system-prompt tool index),
+   * distinct from the fuller `description`.
+   */
+  readonly promptSnippet?: string;
+  /** Optional guideline bullets appended to the default system prompt Guidelines section when this tool is active. */
+  readonly promptGuidelines?: ReadonlyArray<string>;
+  readonly parameters: Params;
+  readonly success: Success;
+  /** Declared, model-visible failures (typed). Omit for tools that cannot fail expectedly. */
+  readonly failure?: Failure;
+  /** Render success for the model. Omit → executor falls back to JSON text. */
+  readonly encodeContent?: (success: Success["Type"]) => ModelContent;
+  /** Render an expected failure for the model. Omit → executor falls back to JSON text. */
+  readonly encodeFailureContent?: (failure: Failure["Type"]) => ModelContent;
+}
+/** A handler: validated params + context → typed success or typed failure. */
+type Handler<Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, R = never> = (params: Params["Type"], ctx: ToolCallContext) => Effect.Effect<Success["Type"], Failure["Type"], R>;
+/** A definition paired with its handler (the unit the executor runs). */
+interface ToolImpl<Name extends string = string, Params extends Schema.Top = Schema.Top, Success extends Schema.Top = Schema.Top, Failure extends Schema.Top = Schema.Top, R = never> {
+  readonly definition: ToolDef<Name, Params, Success, Failure>;
+  readonly handler: Handler<Params, Success, Failure, R>;
+}
+type AnyToolDef = ToolDef<string, any, any, any>;
+type AnyToolImpl<R = never> = ToolImpl<string, any, any, any, R>;
+interface DefineInput<Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top> {
+  readonly name: Name;
+  readonly description: string;
+  readonly label?: string;
+  readonly promptSnippet?: string;
+  readonly parameters: Params;
+  readonly success: Success;
+  readonly failure?: Failure;
+  readonly encodeContent?: (success: Success["Type"]) => ModelContent;
+  readonly encodeFailureContent?: (failure: Failure["Type"]) => ModelContent;
+}
+/** Define a pure tool (handler attached later via {@link implement} or a toolkit). */
+declare const define: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top = Schema.Top>(input: DefineInput<Name, Params, Success, Failure>) => ToolDef<Name, Params, Success, Failure>;
+/** Attach a handler to an existing definition (the testable def/exec split). */
+declare const implement: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, R = never>(definition: ToolDef<Name, Params, Success, Failure>, handler: Handler<Params, Success, Failure, R>) => ToolImpl<Name, Params, Success, Failure, R>;
+/** Sugar for the co-located case: a definition with its handler in one object. */
+declare const make: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top = Schema.Top, R = never>(input: DefineInput<Name, Params, Success, Failure> & {
+  readonly handler: Handler<Params, Success, Failure, R>;
+}) => ToolImpl<Name, Params, Success, Failure, R>;
+/**
+ * A tool ready to register: its capability requirements have been discharged, leaving only
+ * the executor-provided {@link ToolProgress}. The registry and executor hold `RegisteredTool`s
+ * and are non-generic (only `handle` is generic, over a progress sink's `RProgress`), so any
+ * number of tools — built-in or
+ * third-party/plugin — compose without a shared capability union
+ */
+interface RegisteredTool {
+  readonly definition: AnyToolDef;
+  readonly handler: (params: unknown, ctx: ToolCallContext) => Effect.Effect<unknown, ToolExecutionError, ToolProgress>;
+}
+/** Register a tool whose only requirement is the executor-provided progress service. */
+declare const register: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top>(impl: ToolImpl<Name, Params, Success, Failure, ToolProgress>) => RegisteredTool;
+/**
+ * Discharge a tool's capability requirements into a {@link RegisteredTool}, erasing its `R`
+ * (the executor still provides `ToolProgress`). This is the registration boundary: a
+ * plugin/third-party tool provides its own fully-resolved capability Layer here, so the
+ * registry never has to unify anyone's `R`.
+ */
+declare const provide: <Name extends string, Params extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, R>(impl: ToolImpl<Name, Params, Success, Failure, R | ToolProgress>, layer: Layer.Layer<R>) => RegisteredTool;
+/**
+ * Derive a provider-safe JSON Schema object from an Effect Schema. This is the
+ * single boundary that crosses into the provider wire; if a provider rejects a
+ * construct, fix it here. Draft-07 inlines the root (no top-level `$ref`).
+ */
+declare const toProviderJsonSchema: (schema: Schema.Top) => Record<string, unknown>;
+/**
+ * Build the aikit `Message.Tool` wire view from a definition. The derived JSON
+ * Schema object satisfies aikit's `parameters` slot structurally at runtime; the
+ * single localized cast keeps aikit untouched (decision 3-A).
+ */
+declare const toAikitTool: (def: AnyToolDef) => Message.Tool;
+//#endregion
+export { IToolProgress as _, RegisteredTool as a, make$1 as b, ToolImpl as c, make as d, provide as f, tool_d_exports as g, toProviderJsonSchema as h, ModelContent as i, define as l, toAikitTool as m, AnyToolImpl as n, ToolCallContext as o, register as p, Handler as r, ToolDef as s, AnyToolDef as t, implement as u, ToolProgress as v, noop as x, ToolProgressPartial as y };
+//# sourceMappingURL=tool-DuYBgiJf.d.mts.map

package/tool.d.mts

@@ -0,0 +1,2 @@
+import { a as RegisteredTool, c as ToolImpl, d as make, f as provide, h as toProviderJsonSchema, i as ModelContent, l as define, m as toAikitTool, n as AnyToolImpl, o as ToolCallContext, p as register, r as Handler, s as ToolDef, t as AnyToolDef, u as implement } from "./tool-DuYBgiJf.mjs";
+export { AnyToolDef, AnyToolImpl, Handler, ModelContent, RegisteredTool, ToolCallContext, ToolDef, ToolImpl, define, implement, make, provide, register, toAikitTool, toProviderJsonSchema };