@inbrowser/agent 0.0.0-placeholder → 0.1.0

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

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

package/dist/types/session.js

@@ -0,0 +1,11 @@
+/**
+ * `AgentSession` + `SessionEvent` — host-facing surfaces for one
+ * in-flight agent run.
+ *
+ * The session is a generic container — it owns the id, the workspace
+ * + runtime references, the cancellation token, and the typed event
+ * stream. The actual inference algorithm lives in an `AgentStrategy`
+ * (`./strategy.ts`).
+ */
+export {};
+//# sourceMappingURL=session.js.map

package/dist/types/session.js.map

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

package/dist/types/storage.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `Storage` — the platform-level key/value abstraction over
+ * `localStorage` / fs / in-memory. Used for BYOK keys, layout
+ * prefs, last-used project id, recent-sessions cache.
+ *
+ * Distinct from `@pyric/storage` (Firebase Storage adapter for
+ * user-owned cloud data). They live at different layers.
+ */
+export interface Storage {
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+    /** Optionally list keys with a prefix. Implementations may degrade to []. */
+    keys(prefix?: string): string[];
+}
+/** No-op storage. Useful for tests + the headless CLI's default. */
+export declare const noopStorage: Storage;
+/** In-memory storage. Thread-safe within one event loop. */
+export declare function createMemoryStorage(seed?: Record<string, string>): Storage;
+//# sourceMappingURL=storage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/types/storage.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,OAAO;IACtB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAChC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,6EAA6E;IAC7E,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACjC;AAED,oEAAoE;AACpE,eAAO,MAAM,WAAW,EAAE,OASxB,CAAC;AAEH,4DAA4D;AAC5D,wBAAgB,mBAAmB,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAkB1E"}

package/dist/types/storage.js

@@ -0,0 +1,41 @@
+/**
+ * `Storage` — the platform-level key/value abstraction over
+ * `localStorage` / fs / in-memory. Used for BYOK keys, layout
+ * prefs, last-used project id, recent-sessions cache.
+ *
+ * Distinct from `@pyric/storage` (Firebase Storage adapter for
+ * user-owned cloud data). They live at different layers.
+ */
+/** No-op storage. Useful for tests + the headless CLI's default. */
+export const noopStorage = Object.freeze({
+    get: () => null,
+    set: () => {
+        /* ignored */
+    },
+    remove: () => {
+        /* ignored */
+    },
+    keys: () => [],
+});
+/** In-memory storage. Thread-safe within one event loop. */
+export function createMemoryStorage(seed) {
+    const map = new Map(seed ? Object.entries(seed) : []);
+    return {
+        get: (k) => map.get(k) ?? null,
+        set: (k, v) => {
+            map.set(k, v);
+        },
+        remove: (k) => {
+            map.delete(k);
+        },
+        keys: (prefix) => {
+            const out = [];
+            for (const k of map.keys()) {
+                if (prefix === undefined || k.startsWith(prefix))
+                    out.push(k);
+            }
+            return out;
+        },
+    };
+}
+//# sourceMappingURL=storage.js.map

package/dist/types/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/types/storage.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAUH,oEAAoE;AACpE,MAAM,CAAC,MAAM,WAAW,GAAY,MAAM,CAAC,MAAM,CAAC;IAChD,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI;IACf,GAAG,EAAE,GAAG,EAAE;QACR,aAAa;IACf,CAAC;IACD,MAAM,EAAE,GAAG,EAAE;QACX,aAAa;IACf,CAAC;IACD,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE;CACf,CAAC,CAAC;AAEH,4DAA4D;AAC5D,MAAM,UAAU,mBAAmB,CAAC,IAA6B;IAC/D,MAAM,GAAG,GAAG,IAAI,GAAG,CAAiB,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACtE,OAAO;QACL,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,IAAI;QAC9B,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;YACZ,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAChB,CAAC;QACD,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE;YACZ,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAChB,CAAC;QACD,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE;YACf,MAAM,GAAG,GAAa,EAAE,CAAC;YACzB,KAAK,MAAM,CAAC,IAAI,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC;gBAC3B,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;oBAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAChE,CAAC;YACD,OAAO,GAAG,CAAC;QACb,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/types/strategy.d.ts

@@ -0,0 +1,76 @@
+/**
+ * `AgentStrategy` — the pluggable inference algorithm.
+ *
+ * The current ReAct-style single-loop behavior is one strategy;
+ * future planner / graph / parallel-branch strategies are new files
+ * implementing this same interface. The session's external event
+ * surface stays stable; only the internals change.
+ */
+import type { ChatMessage, TurnDetails } from './chat.js';
+import type { LlmClient, RawUsage } from './llm.js';
+import type { RuntimeState } from './runtime.js';
+import type { ToolContext, ToolDispatch, ToolHandler, ToolResult } from './tools.js';
+import type { Tracer } from './trace.js';
+import type { Workspace } from './workspace.js';
+export interface AgentStrategy {
+    readonly id: string;
+    /**
+     * Execute one user prompt to completion. Returns the strategy's
+     * event stream — the session translates it into `SessionEvent`s.
+     */
+    run(input: StrategyRunInput, signal: AbortSignal): AsyncIterable<StrategyEvent>;
+}
+export interface StrategyRunInput {
+    prompt: string;
+    history: ChatMessage[];
+    workspace: Workspace;
+    runtime: RuntimeState;
+    llm: LlmClient;
+    tools: ToolDispatch;
+    /** Already filtered by the active capabilities. */
+    toolList: ToolHandler[];
+    /** Factory — call per tool exec so the latest workspace/runtime flows in. */
+    toolContext(): ToolContext;
+    /** Pre-built by the session from `Workspace` + `RuntimeState`. */
+    systemPrompt: string;
+    /** Optional trace sink — emitted at well-defined moments in the
+     *  loop (request about to dispatch; response complete). The
+     *  strategy never inspects the impl. Absent = zero-cost no-op. */
+    tracer?: Tracer;
+    /** Optional session-scoped id used by the strategy when generating
+     *  per-iteration `requestId`s. The session is what owns the turn
+     *  identity; the strategy receives it for trace labeling only. */
+    turnId?: string;
+}
+export type StrategyEvent = {
+    kind: 'text';
+    chunk: string;
+} | {
+    kind: 'thinking';
+    chunk: string;
+} | {
+    kind: 'tool_call';
+    id: string;
+    name: string;
+    args: unknown;
+    signature?: string;
+} | {
+    kind: 'tool_result';
+    id: string;
+    result: ToolResult;
+} | {
+    kind: 'turn_complete';
+    usage: RawUsage;
+    details: TurnDetails;
+} | {
+    kind: 'error';
+    message: string;
+}
+/** Custom milestone — name + arbitrary payload, surfaced as
+ *  `SessionEvent.kind === 'strategy_event'` to the host. */
+ | {
+    kind: 'custom';
+    name: string;
+    data?: unknown;
+};
+//# sourceMappingURL=strategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../src/types/strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACrF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,GAAG,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,WAAW,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;CACjF;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,YAAY,CAAC;IACtB,GAAG,EAAE,SAAS,CAAC;IACf,KAAK,EAAE,YAAY,CAAC;IACpB,mDAAmD;IACnD,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,6EAA6E;IAC7E,WAAW,IAAI,WAAW,CAAC;IAC3B,kEAAkE;IAClE,YAAY,EAAE,MAAM,CAAC;IACrB;;sEAEkE;IAClE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;sEAEkE;IAClE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAClF;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,WAAW,CAAA;CAAE,GAChE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE;AACpC;4DAC4D;GAC1D;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC"}

package/dist/types/strategy.js

@@ -0,0 +1,10 @@
+/**
+ * `AgentStrategy` — the pluggable inference algorithm.
+ *
+ * The current ReAct-style single-loop behavior is one strategy;
+ * future planner / graph / parallel-branch strategies are new files
+ * implementing this same interface. The session's external event
+ * surface stays stable; only the internals change.
+ */
+export {};
+//# sourceMappingURL=strategy.js.map

package/dist/types/strategy.js.map

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

package/dist/types/tools.d.ts

@@ -0,0 +1,136 @@
+/**
+ * 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;
+    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,125 @@
+/**
+ * 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` shape is
+ * defined here so consumers can write against the full union from
+ * day one; emit-site wiring lands in Phase 2.
+ */
+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 at the moment the request was about to dispatch. */
+    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. Defined now so consumers can switch on
+ * `TraceEvent.kind` and handle the full union from the start. The
+ * emit-site in `strategy.ts` lands in Phase 2 — strategies are free
+ * to emit it earlier when the data is available.
+ */
+export interface LlmResponseTrace {
+    /** Same id as the matching `LlmRequestTrace.requestId`. */
+    requestId: string;
+    /** Wall-clock ms when the chat() iterator completed. */
+    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;
+    };
+}
+export type TraceEvent = {
+    kind: 'llm_request';
+    data: LlmRequestTrace;
+} | {
+    kind: 'llm_response';
+    data: LlmResponseTrace;
+};
+/**
+ * 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;;;;;;;;;;;;;;;;;;;;;GAqBG;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,qEAAqE;IACrE,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;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,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,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,CAAC;AAErD;;;;;;;;;GASG;AACH,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;CAC/B"}

package/dist/types/trace.js

@@ -0,0 +1,24 @@
+/**
+ * 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` shape is
+ * defined here so consumers can write against the full union from
+ * day one; emit-site wiring lands in Phase 2.
+ */
+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;;;;;;;;;;;;;;;;;;;;;GAqBG"}

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.1.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"
 }