@cursor/july 0.1.1

package/dist/internal/approval-gate.d.ts

@@ -0,0 +1,34 @@
+/**
+ * In-memory gate for human-in-the-loop tool approvals. The session
+ * engine parks inside a server-tool `execute` by awaiting
+ * {@link ApprovalGate.wait}; HTTP (or the playground) unblocks via
+ * {@link ApprovalGate.resolve}.
+ *
+ * Pending approvals are also mirrored onto {@link SessionRecord} for
+ * durability of the *list* across reloads. After a process restart the
+ * in-flight SDK tool callback is gone, so resolve returns false and
+ * the host treats the approval as interrupted.
+ */
+import type { ApprovalDecision, PendingApproval } from "../types.js";
+export interface ApprovalResolution {
+    decision: ApprovalDecision;
+    by?: string;
+}
+export declare class ApprovalGate {
+    private readonly waiters;
+    wait(meta: PendingApproval & {
+        sessionId: string;
+    }): Promise<ApprovalResolution>;
+    /**
+     * Unblock a waiter. Returns false when there is no live waiter (e.g. the
+     * host restarted while the tool call was parked).
+     */
+    resolve(sessionId: string, callId: string, decision: ApprovalDecision, resolvedBy?: string): boolean;
+    has(sessionId: string, callId: string): boolean;
+    list(sessionId: string): PendingApproval[];
+    /** Drop waiters for a session (e.g. turn already failed). */
+    cancelSession(sessionId: string, decision?: ApprovalDecision): void;
+    /** Unblock every live waiter (e.g. engine shutdown). */
+    cancelAll(decision?: ApprovalDecision): void;
+}
+//# sourceMappingURL=approval-gate.d.ts.map

package/dist/internal/approval-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-gate.d.ts","sourceRoot":"","sources":["../../src/internal/approval-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAMrE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAOD,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IAErD,IAAI,CACF,IAAI,EAAE,eAAe,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,GAC5C,OAAO,CAAC,kBAAkB,CAAC,CAoB7B;IAED;;;OAGG;IACH,OAAO,CACL,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAcT;IAED,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAE9C;IAED,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE,CASzC;IAED,6DAA6D;IAC7D,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,GAAE,gBAAyB,GAAG,IAAI,CAS1E;IAED,wDAAwD;IACxD,SAAS,CAAC,QAAQ,GAAE,gBAAyB,GAAG,IAAI,CAKnD;CACF"}

package/dist/internal/approval-gate.js

@@ -0,0 +1,85 @@
+/**
+ * In-memory gate for human-in-the-loop tool approvals. The session
+ * engine parks inside a server-tool `execute` by awaiting
+ * {@link ApprovalGate.wait}; HTTP (or the playground) unblocks via
+ * {@link ApprovalGate.resolve}.
+ *
+ * Pending approvals are also mirrored onto {@link SessionRecord} for
+ * durability of the *list* across reloads. After a process restart the
+ * in-flight SDK tool callback is gone, so resolve returns false and
+ * the host treats the approval as interrupted.
+ */
+function approvalKey(sessionId, callId) {
+    return `${sessionId}\0${callId}`;
+}
+export class ApprovalGate {
+    constructor() {
+        this.waiters = new Map();
+    }
+    wait(meta) {
+        const key = approvalKey(meta.sessionId, meta.callId);
+        const existing = this.waiters.get(key);
+        if (existing !== undefined) {
+            throw new Error(`Approval already pending for session ${meta.sessionId} call ${meta.callId}`);
+        }
+        return new Promise((resolveDecision) => {
+            this.waiters.set(key, {
+                meta: {
+                    callId: meta.callId,
+                    turnId: meta.turnId,
+                    toolName: meta.toolName,
+                    args: meta.args,
+                    requestedAt: meta.requestedAt,
+                },
+                resolve: resolveDecision,
+            });
+        });
+    }
+    /**
+     * Unblock a waiter. Returns false when there is no live waiter (e.g. the
+     * host restarted while the tool call was parked).
+     */
+    resolve(sessionId, callId, decision, resolvedBy) {
+        const key = approvalKey(sessionId, callId);
+        const waiter = this.waiters.get(key);
+        if (waiter === undefined) {
+            return false;
+        }
+        this.waiters.delete(key);
+        waiter.resolve(Object.assign({ decision }, (resolvedBy === undefined || resolvedBy === ""
+            ? {}
+            : { by: resolvedBy })));
+        return true;
+    }
+    has(sessionId, callId) {
+        return this.waiters.has(approvalKey(sessionId, callId));
+    }
+    list(sessionId) {
+        const prefix = `${sessionId}\0`;
+        const out = [];
+        for (const [key, waiter] of this.waiters) {
+            if (key.startsWith(prefix)) {
+                out.push(waiter.meta);
+            }
+        }
+        return out;
+    }
+    /** Drop waiters for a session (e.g. turn already failed). */
+    cancelSession(sessionId, decision = "deny") {
+        const prefix = `${sessionId}\0`;
+        for (const [key, waiter] of [...this.waiters.entries()]) {
+            if (!key.startsWith(prefix)) {
+                continue;
+            }
+            this.waiters.delete(key);
+            waiter.resolve({ decision });
+        }
+    }
+    /** Unblock every live waiter (e.g. engine shutdown). */
+    cancelAll(decision = "deny") {
+        for (const waiter of this.waiters.values()) {
+            waiter.resolve({ decision });
+        }
+        this.waiters.clear();
+    }
+}

package/dist/internal/auth.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Auth helpers shared by the HTTP channel, session engine, and session store.
+ */
+import type { AuthContext } from "../types.js";
+export declare function isSafeSessionId(sessionId: string): boolean;
+/** True when both sides identify the same principal (or both are null). */
+export declare function samePrincipal(a: AuthContext | null, b: AuthContext | null): boolean;
+//# sourceMappingURL=auth.d.ts.map

package/dist/internal/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/internal/auth.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAS/C,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAO1D;AAED,2EAA2E;AAC3E,wBAAgB,aAAa,CAC3B,CAAC,EAAE,WAAW,GAAG,IAAI,EACrB,CAAC,EAAE,WAAW,GAAG,IAAI,GACpB,OAAO,CAYT"}

package/dist/internal/auth.js

@@ -0,0 +1,27 @@
+/**
+ * Auth helpers shared by the HTTP channel, session engine, and session store.
+ */
+/**
+ * Session ids must be a single path segment: no `..`, separators, or empty
+ * names. Generated ids use `ses_<24 hex>`; this also admits caller-provided
+ * safe keys without opening path traversal.
+ */
+const SAFE_SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+export function isSafeSessionId(sessionId) {
+    return (SAFE_SESSION_ID.test(sessionId) &&
+        !sessionId.includes("..") &&
+        !sessionId.includes("/") &&
+        !sessionId.includes("\\"));
+}
+/** True when both sides identify the same principal (or both are null). */
+export function samePrincipal(a, b) {
+    if (a === null && b === null) {
+        return true;
+    }
+    if (a === null || b === null) {
+        return false;
+    }
+    return (a.authenticator === b.authenticator &&
+        a.principalId === b.principalId &&
+        a.principalType === b.principalType);
+}

package/dist/internal/authored-alias-hooks.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Node module-customization hooks for authored agent files (registered via
+ * node:module `register()` from authored-loaders.ts; runs on Node's loader
+ * thread — keep this module dependency-free).
+ *
+ * Authored files import the framework by bare specifier. From a published
+ * install those need help in two cases:
+ *
+ * - `@anysphere/agent-serve[/subpath]` (the historical monorepo name) is not
+ *   on npm, so it can never resolve from a user project. `directAliases` map
+ *   it straight onto the running package's dist entries.
+ * - `@cursor/july[/subpath]` (the published name) and `@cursor/agentkit
+ *   [/subpath]` (the future public name) normally resolve through the
+ *   project's own node_modules; `fallbackAliases` only apply when that
+ *   fails (npx/global installs, projects without a local dependency), so a
+ *   real install in the user's project keeps precedence.
+ */
+export interface AuthoredAliasHookData {
+    directAliases: Record<string, string>;
+    fallbackAliases: Record<string, string>;
+}
+export declare function initialize(data: AuthoredAliasHookData): void;
+interface ResolveResult {
+    url: string;
+    shortCircuit?: boolean;
+    format?: string | null;
+}
+type NextResolve = (specifier: string, context: unknown) => ResolveResult | Promise<ResolveResult>;
+export declare function resolve(specifier: string, context: unknown, nextResolve: NextResolve): ResolveResult | Promise<ResolveResult>;
+export {};
+//# sourceMappingURL=authored-alias-hooks.d.ts.map

package/dist/internal/authored-alias-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authored-alias-hooks.d.ts","sourceRoot":"","sources":["../../src/internal/authored-alias-hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAOH,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AAQD,wBAAgB,UAAU,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI,CAG5D;AAED,UAAU,aAAa;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,KAAK,WAAW,GAAG,CACjB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,KACb,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;AAE5C,wBAAgB,OAAO,CACrB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,WAAW,GACvB,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAcxC"}

package/dist/internal/authored-alias-hooks.js

@@ -0,0 +1,43 @@
+/**
+ * Node module-customization hooks for authored agent files (registered via
+ * node:module `register()` from authored-loaders.ts; runs on Node's loader
+ * thread — keep this module dependency-free).
+ *
+ * Authored files import the framework by bare specifier. From a published
+ * install those need help in two cases:
+ *
+ * - `@anysphere/agent-serve[/subpath]` (the historical monorepo name) is not
+ *   on npm, so it can never resolve from a user project. `directAliases` map
+ *   it straight onto the running package's dist entries.
+ * - `@cursor/july[/subpath]` (the published name) and `@cursor/agentkit
+ *   [/subpath]` (the future public name) normally resolve through the
+ *   project's own node_modules; `fallbackAliases` only apply when that
+ *   fails (npx/global installs, projects without a local dependency), so a
+ *   real install in the user's project keeps precedence.
+ */
+// Null-prototype copies so specifiers like "constructor" or "__proto__"
+// can never resolve to inherited Object.prototype members.
+let directAliases = toNullProtoMap({});
+let fallbackAliases = toNullProtoMap({});
+function toNullProtoMap(source) {
+    return Object.assign(Object.create(null), source);
+}
+export function initialize(data) {
+    directAliases = toNullProtoMap(data.directAliases);
+    fallbackAliases = toNullProtoMap(data.fallbackAliases);
+}
+export function resolve(specifier, context, nextResolve) {
+    const direct = directAliases[specifier];
+    if (direct !== undefined) {
+        return { url: direct, shortCircuit: true };
+    }
+    const fallback = fallbackAliases[specifier];
+    if (fallback === undefined) {
+        // Not ours: pass through with no promise/try-catch overhead. This hook
+        // runs on every module resolution in the process.
+        return nextResolve(specifier, context);
+    }
+    return Promise.resolve()
+        .then(() => nextResolve(specifier, context))
+        .catch(() => ({ url: fallback, shortCircuit: true }));
+}

package/dist/internal/authored-loaders.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Process-wide module loaders for authored agent files.
+ *
+ * The CLI dynamically imports user TypeScript (`agent/agent.ts`,
+ * `agent/tools/*.ts`, `evals/**\/*.eval.ts`) at runtime, and plain Node
+ * cannot load `.ts` modules. Instead of requiring hosts to wrap the bin in
+ * `node --import tsx`, the bin (and programmatic `serve()`) registers tsx's
+ * ESM loader itself on startup.
+ *
+ * On compiled runs it additionally registers alias hooks so authored bare
+ * imports of the framework resolve against the running package: the
+ * historical `@anysphere/agent-serve[/x]` name always, and
+ * `@cursor/july[/x]` / `@cursor/agentkit[/x]` as fallbacks when the user's
+ * project has no local install (npx / global). Source runs (tsx from the
+ * monorepo) skip both — the host loader and tsconfig paths already cover
+ * them.
+ */
+/**
+ * Install the runtime loaders for authored agent files. Idempotent; called
+ * from the CLI entry before any command runs, and from `serve()` and the
+ * discovery APIs for programmatic embedders. Concurrent callers share one
+ * registration and all wait for it to finish.
+ */
+export declare function registerAuthoredModuleLoaders(): Promise<void>;
+//# sourceMappingURL=authored-loaders.d.ts.map

package/dist/internal/authored-loaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authored-loaders.d.ts","sourceRoot":"","sources":["../../src/internal/authored-loaders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AA0BH;;;;;GAKG;AACH,wBAAgB,6BAA6B,IAAI,OAAO,CAAC,IAAI,CAAC,CAS7D"}

package/dist/internal/authored-loaders.js

@@ -0,0 +1,129 @@
+/**
+ * Process-wide module loaders for authored agent files.
+ *
+ * The CLI dynamically imports user TypeScript (`agent/agent.ts`,
+ * `agent/tools/*.ts`, `evals/**\/*.eval.ts`) at runtime, and plain Node
+ * cannot load `.ts` modules. Instead of requiring hosts to wrap the bin in
+ * `node --import tsx`, the bin (and programmatic `serve()`) registers tsx's
+ * ESM loader itself on startup.
+ *
+ * On compiled runs it additionally registers alias hooks so authored bare
+ * imports of the framework resolve against the running package: the
+ * historical `@anysphere/agent-serve[/x]` name always, and
+ * `@cursor/july[/x]` / `@cursor/agentkit[/x]` as fallbacks when the user's
+ * project has no local install (npx / global). Source runs (tsx from the
+ * monorepo) skip both — the host loader and tsconfig paths already cover
+ * them.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { register as registerModuleHooks } from "node:module";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { AGENTKIT_PACKAGE_NAME, AUTHORING_ENTRY_FILES, CLI_COMMAND_NAME, isCompiledDistribution, LEGACY_PACKAGE_NAME, PACKAGE_NAME, packageRootDir, } from "./distribution.js";
+/**
+ * Cross-copy markers: a user project with its own `@cursor/july` install
+ * can load a second copy of this module in the same process; tsx and the
+ * alias hooks must only be registered once.
+ */
+const TSX_REGISTERED_KEY = Symbol.for("cursor.agentkit.tsxRegistered");
+const ALIASES_REGISTERED_KEY = Symbol.for("cursor.agentkit.aliasesRegistered");
+let registration;
+/**
+ * Install the runtime loaders for authored agent files. Idempotent; called
+ * from the CLI entry before any command runs, and from `serve()` and the
+ * discovery APIs for programmatic embedders. Concurrent callers share one
+ * registration and all wait for it to finish.
+ */
+export function registerAuthoredModuleLoaders() {
+    if (!isCompiledDistribution()) {
+        return Promise.resolve();
+    }
+    registration !== null && registration !== void 0 ? registration : (registration = (() => __awaiter(this, void 0, void 0, function* () {
+        yield registerTsxLoader();
+        registerFrameworkAliases();
+    }))());
+    return registration;
+}
+function registerTsxLoader() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Escape hatch for hosts that precompile authored files to .js (or bring
+        // their own loader) and don't want tsx hooked into module resolution.
+        if (process.env.AGENT_SERVE_DISABLE_TSX === "1") {
+            return;
+        }
+        if (tsxAlreadyActive()) {
+            return;
+        }
+        try {
+            const tsx = (yield import("tsx/esm/api"));
+            if (typeof tsx.register !== "function") {
+                throw new Error("tsx/esm/api has no register export");
+            }
+            tsx.register();
+            globalThis[TSX_REGISTERED_KEY] = true;
+        }
+        catch (error) {
+            process.stderr.write(`[${CLI_COMMAND_NAME}] tsx loader unavailable (${error instanceof Error ? error.message : String(error)}); authored TypeScript files will not load — install tsx or precompile the agent to .js\n`);
+        }
+    });
+}
+/**
+ * Whether a tsx loader is already installed process-wide: by a previous call
+ * from another copy of this module, or by the host command line (the Docker
+ * flow still runs `node --import tsx dist/bin/agent-serve.js`).
+ */
+function tsxAlreadyActive() {
+    var _a;
+    var _b;
+    if (globalThis[TSX_REGISTERED_KEY] === true) {
+        return true;
+    }
+    const hostArgs = [
+        ...process.execArgv,
+        ...((_b = (_a = process.env.NODE_OPTIONS) === null || _a === void 0 ? void 0 : _a.split(/\s+/)) !== null && _b !== void 0 ? _b : []),
+    ];
+    for (let i = 0; i < hostArgs.length; i++) {
+        const arg = hostArgs[i];
+        if (arg === "--import" || arg === "--loader" || arg === "--require") {
+            const value = hostArgs[i + 1];
+            if (value === "tsx" || (value === null || value === void 0 ? void 0 : value.startsWith("tsx/"))) {
+                return true;
+            }
+        }
+        else if (arg !== undefined &&
+            /^--(import|loader|require)=tsx(\/|$)/.test(arg)) {
+            return true;
+        }
+    }
+    return false;
+}
+function registerFrameworkAliases() {
+    const markers = globalThis;
+    if (markers[ALIASES_REGISTERED_KEY] === true) {
+        return;
+    }
+    const distDir = join(packageRootDir(), "dist");
+    const directAliases = {};
+    const fallbackAliases = {};
+    for (const [subpath, file] of AUTHORING_ENTRY_FILES) {
+        const target = pathToFileURL(join(distDir, file)).href;
+        const suffix = subpath === "" ? "" : `/${subpath}`;
+        directAliases[`${LEGACY_PACKAGE_NAME}${suffix}`] = target;
+        fallbackAliases[`${PACKAGE_NAME}${suffix}`] = target;
+        fallbackAliases[`${AGENTKIT_PACKAGE_NAME}${suffix}`] = target;
+    }
+    const hooksUrl = new URL("./authored-alias-hooks.js", import.meta.url);
+    const data = { directAliases, fallbackAliases };
+    // `node:module`'s register() is synchronous: it blocks until the hooks
+    // thread has initialized, so the aliases are active when it returns.
+    registerModuleHooks(hooksUrl, { data });
+    markers[ALIASES_REGISTERED_KEY] = true;
+}

package/dist/internal/bounded-int.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared validation for optional config ceilings (playground windows, etc.).
+ */
+export declare function normalizePositiveInt(value: unknown, options: {
+    /** e.g. `evals.config.ts: maxPlaygroundRuns` */
+    label: string;
+    max: number;
+    /** Override the default "exceeds the hard limit" message body after the label. */
+    maxMessage?: string;
+}): number;
+//# sourceMappingURL=bounded-int.d.ts.map

package/dist/internal/bounded-int.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-int.d.ts","sourceRoot":"","sources":["../../src/internal/bounded-int.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,OAAO,EAAE;IACP,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,kFAAkF;IAClF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GACA,MAAM,CAaR"}

package/dist/internal/bounded-int.js

@@ -0,0 +1,13 @@
+/**
+ * Shared validation for optional config ceilings (playground windows, etc.).
+ */
+export function normalizePositiveInt(value, options) {
+    var _a;
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+        throw new Error(`${options.label} must be a positive integer (got ${String(value)})`);
+    }
+    if (value > options.max) {
+        throw new Error((_a = options.maxMessage) !== null && _a !== void 0 ? _a : `${options.label} ${value} exceeds the hard limit of ${options.max}`);
+    }
+    return value;
+}

package/dist/internal/brand.d.ts

@@ -0,0 +1,6 @@
+import type { BrandedDefinition, DefinitionKind } from "../types.js";
+export declare const DEFINITION_BRAND_FIELD = "__agentServe";
+export declare function brandDefinition<K extends DefinitionKind, T extends object>(kind: K, definition: T): T & BrandedDefinition<K>;
+export declare function getDefinitionKind(value: unknown): DefinitionKind | undefined;
+export declare function isDefinitionOfKind<K extends DefinitionKind>(value: unknown, kind: K): value is BrandedDefinition<K>;
+//# sourceMappingURL=brand.d.ts.map

package/dist/internal/brand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brand.d.ts","sourceRoot":"","sources":["../../src/internal/brand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAErE,eAAO,MAAM,sBAAsB,iBAAiB,CAAC;AAErD,wBAAgB,eAAe,CAAC,CAAC,SAAS,cAAc,EAAE,CAAC,SAAS,MAAM,EACxE,IAAI,EAAE,CAAC,EACP,UAAU,EAAE,CAAC,GACZ,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAG1B;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAS5E;AAED,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,cAAc,EACzD,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,CAAC,GACN,KAAK,IAAI,iBAAiB,CAAC,CAAC,CAAC,CAE/B"}

package/dist/internal/brand.js

@@ -0,0 +1,17 @@
+export const DEFINITION_BRAND_FIELD = "__agentServe";
+export function brandDefinition(kind, definition) {
+    return Object.assign(Object.assign({}, definition), { [DEFINITION_BRAND_FIELD]: kind });
+}
+export function getDefinitionKind(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const kind = value[DEFINITION_BRAND_FIELD];
+    if (typeof kind !== "string") {
+        return undefined;
+    }
+    return kind;
+}
+export function isDefinitionOfKind(value, kind) {
+    return getDefinitionKind(value) === kind;
+}

package/dist/internal/chat-client.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `agent-serve chat` — a minimal terminal client for a served agent. It
+ * drives only the public HTTP API (create session, follow-up, NDJSON
+ * stream), so it works against any agent-serve server and demonstrates the
+ * same wire protocol the playground and curl use. Renders streamed
+ * assistant text live, tool calls inline, and a per-turn usage footer.
+ */
+export interface ChatClientOptions {
+    baseUrl: string;
+    bearerToken?: string;
+    /** One-shot: send this message, stream the reply, then exit. */
+    message?: string;
+    /** Force plain output even on a TTY. */
+    noColor?: boolean;
+    logger?: (line: string) => void;
+}
+/** Run the terminal chat client. Resolves when the session/REPL ends. */
+export declare function runChat(options: ChatClientOptions): Promise<void>;
+//# sourceMappingURL=chat-client.d.ts.map

package/dist/internal/chat-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-client.d.ts","sourceRoot":"","sources":["../../src/internal/chat-client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wCAAwC;IACxC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAyCD,yEAAyE;AACzE,wBAAsB,OAAO,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+GvE"}