@inbrowser/agent 0.0.0-placeholder → 0.2.0

package/dist/types/tools.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Tool registry + dispatch + handler types.
+ *
+ * The `ToolRegistry` is a configuration concern (what tools exist);
+ * `ToolDispatch` is a runtime concern (run the named one against this
+ * context). Splitting them lets a host wire the catalog at startup
+ * with `registry.register(handler)` and lets concurrent sessions
+ * share a stateless dispatcher.
+ */
+import type { Capabilities } from './capabilities.js';
+import type { JsonSchema } from './llm.js';
+import type { RuntimeState } from './runtime.js';
+import type { StitchContext, Workspace } from './workspace.js';
+export interface ToolHandler<A = unknown, D = unknown> {
+    name: string;
+    description: string;
+    parameters: JsonSchema;
+    /** Capability gate — handler is excluded from `list()` when this returns false. */
+    available?(capabilities: Capabilities): boolean;
+    /**
+     * Opt-in: the dispatcher is allowed to run this tool concurrently with
+     * other `parallelSafe` tools issued in the same turn. Absent or `false`
+     * means the conservative default — the dispatcher treats it as not safe
+     * to parallelize. Read this field via {@link isParallelSafe} so the
+     * default is applied uniformly. Pure-tool dispatchers (parallel
+     * scheduling) consume this; tag-only branches do not change runtime
+     * behavior.
+     */
+    parallelSafe?: boolean;
+    /**
+     * Opt-in: calling this tool with the same arguments against the same
+     * workspace state always produces the same result, so a content-addressed
+     * cache may serve repeat calls. Absent or `false` means the conservative
+     * default — the dispatch layer must execute the handler every call. Read
+     * this field via {@link isPure} so the default is applied uniformly.
+     */
+    pure?: boolean;
+    execute(args: A, ctx: ToolContext): Promise<ToolResult<D>>;
+}
+/**
+ * Session-scoped context handed to every tool's `execute`. Kept
+ * narrow per F8 — only `signal` is required; everything else is
+ * optional so headless hosts (Deployment Agent, MCP server) don't
+ * have to mock playground-shaped state.
+ *
+ * Per F2 + F5, factories capture their own deps at construction
+ * time (closure) and tool handlers only read from {deps, args, ctx}.
+ * Don't grow this interface to satisfy specific factories.
+ */
+export interface ToolContext {
+    /** Cancellation signal — tools should respect it for long-running ops. */
+    signal: AbortSignal;
+    /** Playground / session workspace (rules source, agent JS, etc.). */
+    workspace?: Workspace;
+    /** Playground / session runtime state (last sandbox run, etc.). */
+    runtime?: RuntimeState;
+    /** Per-session sandbox handle, when the host has one. */
+    sandbox?: SandboxHandle;
+    /** Pure-function lint, injected for testability. */
+    lint?: LintFn;
+    /** Optional Stitch client — absent when capability disables it. */
+    stitch?: StitchClient;
+}
+/**
+ * Minimal sandbox surface tools need. The host injects a concrete
+ * adapter (today: `@pyric/sandbox` runner). Kept narrow so tool tests
+ * can stub it without pulling in the whole sandbox package.
+ */
+export interface SandboxHandle {
+    run(code: string, signal?: AbortSignal): Promise<{
+        ok: boolean;
+        durationMs: number;
+        docsTouched: number;
+        errors: number;
+        entries: unknown[];
+    }>;
+    deployRules(source: string): Promise<{
+        ok: boolean;
+        messages: {
+            severity: 'info' | 'warn' | 'error';
+            text: string;
+            line?: number;
+            column?: number;
+        }[];
+    }>;
+    readState(opts?: {
+        path?: string;
+        maxDepth?: number;
+    }): Promise<unknown>;
+    reseed(opts: {
+        presetId: string;
+    }): void;
+    dispose(): void;
+}
+export type LintFn = (source: string) => {
+    warnings: LintWarning[];
+};
+export interface LintWarning {
+    severity: 'info' | 'warn' | 'error';
+    message: string;
+    line?: number;
+    column?: number;
+}
+/** Optional Stitch design client. Absent in headless / capability-off runs. */
+export interface StitchClient {
+    hasKey(): boolean;
+    context(): StitchContext;
+}
+export interface ToolResult<D = unknown> {
+    ok: boolean;
+    /** One-line human-readable summary the model can quote back. */
+    summary: string;
+    data?: D;
+    /** Patches applied by the session to its own state. */
+    workspacePatch?: Partial<Workspace>;
+    runtimePatch?: Partial<RuntimeState>;
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    args: unknown;
+}
+export interface ToolRegistry {
+    /**
+     * Register a new handler. **Throws** if `handler.name` is already
+     * present — catches the "accidentally registered two factories
+     * with overlapping tools" footgun (F6). Use `replace` for explicit
+     * overlays.
+     */
+    register(handler: ToolHandler): void;
+    /**
+     * Idempotent registration. Replaces an existing handler with the
+     * same name, or registers fresh. The standard shape for
+     * decoration via `.map` before register (F7):
+     *
+     * ```ts
+     * for (const t of createXxxTools(deps).map(wrapMutating)) {
+     *   registry.register(t);  // or replace(t) if re-wrapping
+     * }
+     * ```
+     */
+    replace(handler: ToolHandler): void;
+    unregister(name: string): boolean;
+    list(opts?: {
+        capabilities?: Capabilities;
+    }): ToolHandler[];
+    has(name: string): boolean;
+    /** Copy-on-write fork for per-session catalog overrides. */
+    fork(): ToolRegistry;
+}
+export interface ToolDispatch {
+    execute(call: ToolCall, ctx: ToolContext): Promise<ToolResult>;
+}
+//# sourceMappingURL=tools.d.ts.map

package/dist/types/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/types/tools.ts"],"names":[],"mappings":"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"}

package/dist/types/tools.js

@@ -0,0 +1,11 @@
+/**
+ * Tool registry + dispatch + handler types.
+ *
+ * The `ToolRegistry` is a configuration concern (what tools exist);
+ * `ToolDispatch` is a runtime concern (run the named one against this
+ * context). Splitting them lets a host wire the catalog at startup
+ * with `registry.register(handler)` and lets concurrent sessions
+ * share a stateless dispatcher.
+ */
+export {};
+//# sourceMappingURL=tools.js.map

package/dist/types/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../src/types/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/types/trace.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Agent-loop request/response trace surface.
+ *
+ * Captures the exact shape of every LLM request the strategy
+ * dispatches — system prompt + messages + tool decls + model — at
+ * the layer the agent author thinks in (`@inbrowser/agent` types), not
+ * the provider-specific transform below it. A provider-level trace
+ * (Gemini's `GeminiBody`, OpenRouter's `messages[].content` parts)
+ * is a complementary concern that belongs to `@inbrowser/relay`;
+ * this surface is for "what did the model see, in agent terms."
+ *
+ * Emission is opt-in. A `Tracer` plugs into `AgentSessionConfig`
+ * (which threads it through `StrategyRunInput`); strategies that
+ * support tracing call `tracer.emit(...)` at well-defined moments.
+ * Strategies without a tracer field — or sessions that don't pass
+ * one — incur zero cost.
+ *
+ * Phase 1 captures `llm_request` only (the priority the playground
+ * needs to ship a prompt visualizer). `llm_response` and
+ * `turn_dispatch_complete` complete the per-iteration wall-clock
+ * triple — request-dispatched, response-completed, tool-dispatch-
+ * completed — that the eval harness uses to split language-model
+ * time from tool-dispatch time.
+ */
+import type { NormalizedMessage } from './chat.js';
+/**
+ * Wire-level snapshot of a single LLM request as it leaves the
+ * strategy. Captured exactly once per ReAct iteration — N times per
+ * user prompt, where N >= 1 (final-answer turn) and grows by 1 per
+ * tool-using iteration.
+ */
+export interface LlmRequestTrace {
+    /** Stable per-iteration id, scoped to its session. The recommended
+     *  format is `${turnId}#${iteration}`; the agent loop generates
+     *  the value, hosts treat it as opaque. */
+    requestId: string;
+    /** The session-scoped turn id (matches `SessionEvent.turnId`). */
+    turnId: string;
+    /** 0-indexed ReAct iteration within this turn. */
+    iteration: number;
+    /** Wall-clock ms captured immediately before the strategy hands
+     *  the request to `LlmClient.chat()`. Pair with
+     *  `LlmResponseTrace.ts` (response completed) and
+     *  `TurnDispatchCompleteTrace.ts` (tool dispatch completed) to
+     *  derive the language-model vs tool-dispatch wall-clock split for
+     *  this iteration. */
+    ts: number;
+    /** The system-prompt string the strategy received from
+     *  `StrategyRunInput.systemPrompt`. Captured verbatim. */
+    systemPrompt: string;
+    /** The messages array exactly as the provider will see it. Includes
+     *  the synthesized leading system message, the prior history, the
+     *  current user prompt, and any assistant+tool entries the ReAct
+     *  loop appended this turn. */
+    messages: NormalizedMessage[];
+    /** Tool declarations as filtered + shaped by the strategy. The
+     *  `parameters` value is captured opaquely — providers normalize
+     *  it (Gemini sanitizes; OpenRouter is permissive), so the trace
+     *  shows the pre-provider canonical view. */
+    tools: ToolDeclarationView[];
+    /** Agent-loop-level model identity. The host enriches this with
+     *  provider label / model label / temperature / reasoning-effort
+     *  at consumption time — those values aren't visible to the
+     *  strategy. */
+    llm: {
+        id: string;
+        supportsTools: boolean;
+    };
+}
+/**
+ * Tool-decl row as the agent loop produced it pre-provider. Mirrors
+ * the `toolDecls` shape strategy.ts builds when constructing the
+ * `ChatRequest`. Not coupled to the in-process `ToolHandler` type —
+ * the trace is a wire snapshot, not a live handle.
+ */
+export interface ToolDeclarationView {
+    name: string;
+    description: string;
+    parameters: unknown;
+}
+/**
+ * Response-side snapshot. Emitted once per ReAct iteration, paired
+ * one-to-one with `LlmRequestTrace` via `requestId`. Captures the
+ * full assistant output and the timestamp at which the chat()
+ * iterator drained — `ts - LlmRequestTrace.ts` is the iteration's
+ * language-model wall-clock segment.
+ */
+export interface LlmResponseTrace {
+    /** Same id as the matching `LlmRequestTrace.requestId`. */
+    requestId: string;
+    /** Wall-clock ms captured immediately after the `chat()` iterator
+     *  has yielded its terminal event for this iteration (typically
+     *  `turn_complete`, or `error` on a streaming failure). Not
+     *  emitted on mid-stream error — callers should treat a missing
+     *  `llm_response` as "language-model time unknown for this
+     *  iteration." */
+    ts: number;
+    /** Full assistant text emitted this iteration. */
+    text: string;
+    /** Hidden reasoning when the model surfaces it. Empty string for
+     *  non-reasoning models. */
+    thinking: string;
+    /** Tool calls the model chose to emit this iteration. */
+    toolCalls: {
+        id: string;
+        name: string;
+        args: unknown;
+        signature?: string;
+    }[];
+    /** Provider-reported usage; absent on error / streaming-cancel /
+     *  for providers that don't surface usage. */
+    usage?: {
+        promptTokens: number;
+        outputTokens: number;
+        cachedTokens?: number;
+    };
+}
+/**
+ * End-of-iteration tool-dispatch marker. Emitted once per ReAct
+ * iteration that actually ran tool calls, immediately after the
+ * per-turn dispatch loop drained. Paired one-to-one with
+ * `LlmResponseTrace` via `requestId`. NOT emitted for the final
+ * assistant turn (no tool calls → no dispatch segment to close).
+ *
+ * `ts - LlmResponseTrace.ts` is the iteration's tool-dispatch
+ * wall-clock segment; `ts - LlmRequestTrace.ts` is the iteration's
+ * total wall-clock from request dispatch through tool-result append.
+ *
+ * Only the aggregate is captured. Per-tool wall-clock can be added
+ * later — the existing `tool_call`/`tool_result` events on the
+ * strategy event stream are the right place for that, not the
+ * trace.
+ */
+export interface TurnDispatchCompleteTrace {
+    /** Same id as the matching `LlmRequestTrace.requestId`. */
+    requestId: string;
+    /** Mirror of `LlmRequestTrace.turnId`, carried for grouping
+     *  consumers that key by turn rather than by iteration. */
+    turnId: string;
+    /** 0-indexed ReAct iteration within the turn. Mirrors
+     *  `LlmRequestTrace.iteration`. */
+    iteration: number;
+    /** Wall-clock ms captured immediately after the last tool result
+     *  for this iteration was appended to the messages array, before
+     *  the loop steps to the next iteration. */
+    ts: number;
+    /** Number of tool calls executed in this iteration. Always >= 1
+     *  in practice (an iteration with zero tool calls does not emit
+     *  this event). */
+    toolCallCount: number;
+}
+export type TraceEvent = {
+    kind: 'llm_request';
+    data: LlmRequestTrace;
+} | {
+    kind: 'llm_response';
+    data: LlmResponseTrace;
+} | {
+    kind: 'turn_dispatch_complete';
+    data: TurnDispatchCompleteTrace;
+};
+/**
+ * Pluggable trace sink. Hosts implement `emit()` to push events to a
+ * UI store, a NDJSON file, an eval harness, etc. The agent loop
+ * never inspects the implementation — it just hands off the event.
+ *
+ * Implementations MUST be synchronous and non-throwing. The agent
+ * loop intentionally doesn't `await` emit; surfacing a trace must
+ * never delay an LLM dispatch or fail it. If a host needs async
+ * work (network ship, etc.), it should queue internally.
+ */
+export interface Tracer {
+    emit(event: TraceEvent): void;
+}
+//# sourceMappingURL=trace.d.ts.map

package/dist/types/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/types/trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B;;+CAE2C;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;0BAKsB;IACtB,EAAE,EAAE,MAAM,CAAC;IACX;8DAC0D;IAC1D,YAAY,EAAE,MAAM,CAAC;IACrB;;;mCAG+B;IAC/B,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B;;;iDAG6C;IAC7C,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B;;;oBAGgB;IAChB,GAAG,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,OAAO,CAAA;KAAE,CAAC;CAC7C;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;sBAKkB;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb;gCAC4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,SAAS,EAAE;QACT,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,OAAO,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,EAAE,CAAC;IACJ;kDAC8C;IAC9C,KAAK,CAAC,EAAE;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/E;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,yBAAyB;IACxC,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB;+DAC2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf;uCACmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB;;gDAE4C;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX;;uBAEmB;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE,gBAAgB,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,wBAAwB,CAAC;IAAC,IAAI,EAAE,yBAAyB,CAAA;CAAE,CAAC;AAExE;;;;;;;;;GASG;AACH,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;CAC/B"}

package/dist/types/trace.js

@@ -0,0 +1,26 @@
+/**
+ * Agent-loop request/response trace surface.
+ *
+ * Captures the exact shape of every LLM request the strategy
+ * dispatches — system prompt + messages + tool decls + model — at
+ * the layer the agent author thinks in (`@inbrowser/agent` types), not
+ * the provider-specific transform below it. A provider-level trace
+ * (Gemini's `GeminiBody`, OpenRouter's `messages[].content` parts)
+ * is a complementary concern that belongs to `@inbrowser/relay`;
+ * this surface is for "what did the model see, in agent terms."
+ *
+ * Emission is opt-in. A `Tracer` plugs into `AgentSessionConfig`
+ * (which threads it through `StrategyRunInput`); strategies that
+ * support tracing call `tracer.emit(...)` at well-defined moments.
+ * Strategies without a tracer field — or sessions that don't pass
+ * one — incur zero cost.
+ *
+ * Phase 1 captures `llm_request` only (the priority the playground
+ * needs to ship a prompt visualizer). `llm_response` and
+ * `turn_dispatch_complete` complete the per-iteration wall-clock
+ * triple — request-dispatched, response-completed, tool-dispatch-
+ * completed — that the eval harness uses to split language-model
+ * time from tool-dispatch time.
+ */
+export {};
+//# sourceMappingURL=trace.js.map

package/dist/types/trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.js","sourceRoot":"","sources":["../../src/types/trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG"}

package/dist/types/workspace.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `Workspace` — the user-authored half of the playground's state.
+ *
+ * Pure data. Immutable updates via the `WorkspaceTransitions`
+ * functions; no I/O, no React, no `localStorage`. Persistence is the
+ * host's job (Zustand in the React IDE, in-memory in the CLI).
+ *
+ * Distinct from `RuntimeState` (`./runtime.ts`), which holds what the
+ * agent's tools have produced — separate concerns, separate types.
+ */
+export interface Workspace {
+    /** Identifier of the active preset (e.g. "chess", "lobby", "owner"). */
+    presetId: string;
+    /** Firestore rules source the user / agent is currently editing. */
+    rules: string;
+    /** JavaScript code source for the agent's `runCode` tool. */
+    code: string;
+    /** TSX source for the App-panel rendered preview. */
+    appSource: string;
+    /** Stitch design context — orthogonal to rules/code/app, but session-scoped. */
+    stitch: StitchContext;
+}
+export interface StitchContext {
+    projectId: string | null;
+    latestScreenUrl: string | null;
+    brief: string | null;
+}
+export declare const EMPTY_WORKSPACE: Workspace;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/types/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/types/workspace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,SAAS;IACxB,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,MAAM,EAAE,aAAa,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,eAAO,MAAM,eAAe,EAAE,SAMf,CAAC"}

package/dist/types/workspace.js

@@ -0,0 +1,18 @@
+/**
+ * `Workspace` — the user-authored half of the playground's state.
+ *
+ * Pure data. Immutable updates via the `WorkspaceTransitions`
+ * functions; no I/O, no React, no `localStorage`. Persistence is the
+ * host's job (Zustand in the React IDE, in-memory in the CLI).
+ *
+ * Distinct from `RuntimeState` (`./runtime.ts`), which holds what the
+ * agent's tools have produced — separate concerns, separate types.
+ */
+export const EMPTY_WORKSPACE = Object.freeze({
+    presetId: '',
+    rules: '',
+    code: '',
+    appSource: '',
+    stitch: Object.freeze({ projectId: null, latestScreenUrl: null, brief: null }),
+});
+//# sourceMappingURL=workspace.js.map

package/dist/types/workspace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.js","sourceRoot":"","sources":["../../src/types/workspace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAqBH,MAAM,CAAC,MAAM,eAAe,GAAc,MAAM,CAAC,MAAM,CAAC;IACtD,QAAQ,EAAE,EAAE;IACZ,KAAK,EAAE,EAAE;IACT,IAAI,EAAE,EAAE;IACR,SAAS,EAAE,EAAE;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,eAAe,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAkB;CAChG,CAAc,CAAC"}

package/package.json

@@ -1,17 +1,48 @@
 {
   "name": "@inbrowser/agent",
-  "public": true,
-  "version": "0.0.0-placeholder",
-  "description": ".",
-  "main": "index.js",
-  "license": "Apache 2.0",
-  "author": "David East",
-  "keywords": [
-    "agent",
-    "agents",
-    "llm",
-    "ai",
-    "browser",
-    "runtime"
-  ]
+  "version": "0.2.0",
+  "description": "Agent runtime + CLI. Library exports AgentSession, AgentStrategy, ToolRegistry, LlmClient, MetricsCollector, SandboxObserver. Ships an `agent` binary with NDJSON output, --json stdin, --dry-run, schema introspection, and inverse-mode MCP serve. Domain-agnostic — hosts wire their own AgentDefinitions.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./cli": {
+      "types": "./dist/cli/index.d.ts",
+      "import": "./dist/cli/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    }
+  },
+  "bin": {
+    "agent": "./bin/agent.ts"
+  },
+  "files": ["dist", "bin", "skills", "AGENTS.md", "README.md"],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@opentui/core": "^0.1.0",
+    "@opentui/react": "^0.1.0",
+    "react": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": "^19.0.0",
+    "typescript": "^5.7.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/davideast/inbrowser-agent.git",
+    "directory": "packages/agent"
+  },
+  "license": "MIT"
 }