@agent-builder-lab/eve-kit 0.0.0-stage → 0.1.0

package/dist/authorization.d.ts

@@ -0,0 +1,78 @@
+import { ApprovalPolicy } from 'eve/tools/approval';
+
+/** Chave do `clientContext` com a conta de teste do turno. */
+declare const LAB_ACCOUNT_CONTEXT_KEY = "labAccount";
+/** Atributo do auth do turno com a conta (JSON), para as ferramentas e os hooks lerem. */
+declare const LAB_ACCOUNT_ATTRIBUTE = "labAccount";
+interface LabAccount {
+    readonly v: 1;
+    readonly id: string;
+    readonly name: string;
+    readonly role: string;
+    readonly roleName: string;
+    /** Recursos liberados: `tool:agendar_consulta`, `data:agenda`, `agent:confirmador`… */
+    readonly grants: readonly string[];
+    /** Nome legível de cada recurso, para o motivo da negação. */
+    readonly labels: Readonly<Record<string, string>>;
+    /** O cadastro de quem conversa, quando a conta tem um (ex.: o paciente da conversa). */
+    readonly patientId?: string;
+}
+/** Confere o formato sem confiar em nada além do necessário; fora do formato, undefined. */
+declare function readLabAccount(value: unknown): LabAccount | undefined;
+/** A conta de teste que o lab mandou no `clientContext` do pedido, ou undefined. */
+declare function labAccountFromContext(context: unknown): LabAccount | undefined;
+type AuthLike = {
+    readonly attributes?: Readonly<Record<string, string | readonly string[]>>;
+};
+/** A conta guardada nos atributos de um auth (o `labChannel()` grava). */
+declare function labAccountFromAuth(auth: AuthLike | null | undefined): LabAccount | undefined;
+/**
+ * A conta de teste do turno, para usar dentro de uma ferramenta, de um hook ou de uma política:
+ * `labAccountOf(ctx)?.name`. Sem o lab (ou fora do Chat do lab), undefined.
+ */
+declare function labAccountOf(ctx: {
+    readonly session: {
+        readonly auth: {
+            readonly current: AuthLike | null;
+        };
+    };
+}): LabAccount | undefined;
+/** Motivo da negação, igual ao que o lab espera ler (`deniedResourceOf` em @lab/access). */
+declare function labDenialReason(account: LabAccount, resource: string): string;
+interface LabAuthorizationOptions<TInput = Record<string, unknown>> {
+    /**
+     * Dados que a ferramenta toca: nomes (`"agenda"`) ou ids (`"data:agenda"`). Pode depender da
+     * entrada: `(input) => input?.cpf ? ["pacientes"] : []`.
+     */
+    readonly data?: readonly string[] | ((input: Readonly<TInput> | undefined) => readonly string[]);
+    /** Subagente dono da ferramenta: exige `agent:<nome>` (a conta pode delegar a ele?). */
+    readonly agent?: string;
+    /**
+     * Exige `tool:<nome da ferramenta>`. Padrão: sim nas ferramentas do agente principal e não nas
+     * de um subagente (que o lab cobre pelo próprio subagente).
+     */
+    readonly tool?: boolean;
+}
+/** Os recursos que uma chamada precisa, na ordem em que o harness confere. */
+declare function requiredResources<TInput>(toolName: string, input: Readonly<TInput> | undefined, options?: LabAuthorizationOptions<TInput>): string[];
+/**
+ * Política de `approval` que confere a conta de teste do turno antes de a ferramenta rodar:
+ *
+ * ```ts
+ * import { labAuthorization } from "@agent-builder-lab/eve-kit/authorization";
+ * export default defineTool({
+ *   description: "Marca uma consulta.",
+ *   approval: labAuthorization({ data: ["agenda", "pacientes"] }),
+ *   async execute(input) { … },
+ * });
+ * ```
+ *
+ * Sem conta do lab no turno (o agente fora do lab, ou um pedido que não veio do Chat), não muda
+ * nada: devolve "not-applicable" e a ferramenta roda como sempre. `next` encadeia outra política
+ * (como `always()`), consultada só quando a conta pode usar a ferramenta.
+ */
+declare function labAuthorization<TInput = Record<string, unknown>>(options?: LabAuthorizationOptions<TInput> & {
+    readonly next?: ApprovalPolicy<TInput>;
+}): ApprovalPolicy<TInput>;
+
+export { LAB_ACCOUNT_ATTRIBUTE, LAB_ACCOUNT_CONTEXT_KEY, type LabAccount, type LabAuthorizationOptions, labAccountFromAuth, labAccountFromContext, labAccountOf, labAuthorization, labDenialReason, readLabAccount, requiredResources };

package/dist/authorization.js

@@ -0,0 +1,22 @@
+import {
+  LAB_ACCOUNT_ATTRIBUTE,
+  LAB_ACCOUNT_CONTEXT_KEY,
+  labAccountFromAuth,
+  labAccountFromContext,
+  labAccountOf,
+  labAuthorization,
+  labDenialReason,
+  readLabAccount,
+  requiredResources
+} from "./chunk-LQIDQBNW.js";
+export {
+  LAB_ACCOUNT_ATTRIBUTE,
+  LAB_ACCOUNT_CONTEXT_KEY,
+  labAccountFromAuth,
+  labAccountFromContext,
+  labAccountOf,
+  labAuthorization,
+  labDenialReason,
+  readLabAccount,
+  requiredResources
+};

package/dist/channel.d.ts

@@ -0,0 +1,39 @@
+import { AuthFn } from 'eve/channels/auth';
+import { EveChannelInput, EveChannel, EveMessageContext, EveMessageResult } from 'eve/channels/eve';
+
+interface LabChannelOptions extends Omit<EveChannelInput, "auth"> {
+    /**
+     * Autenticadores do próprio agente, verificados antes do acesso local do lab. O acesso local
+     * (`localDev()` do eve) entra sempre por último.
+     */
+    auth?: AuthFn<Request> | readonly AuthFn<Request>[];
+    /** Porta local do conector. Padrão: `LAB_CONNECTOR_URL` ou http://127.0.0.1:2100. */
+    connectorUrl?: string;
+}
+/**
+ * Canal HTTP do eve com o que o Agent Builder Lab precisa para reexecutar o loop e conferir a
+ * conta de teste, para `agent/channels/eve.ts`:
+ *
+ * ```ts
+ * import { labChannel } from "@agent-builder-lab/eve-kit/channel";
+ * export default labChannel();
+ * ```
+ *
+ * - Em `eve dev`, chamadas de loopback ganham `allowToolStubs`: o lab troca o resultado das
+ *   ferramentas por saídas gravadas ou simuladas, e nada executa de verdade.
+ * - Quando o pedido traz um fork do lab (`clientContext.labFork.id`), busca no conector o
+ *   histórico dos turnos anteriores e o devolve ao eve como `history`. O id vai para os
+ *   atributos do auth do turno (para o `labReplayModel`) e sai do contexto que o modelo vê.
+ * - Quando o pedido traz a conta de teste ("Enviando como", `clientContext.labAccount`), ela vai
+ *   para os atributos do auth do turno (`labAccount`), onde `labAuthorization()` confere cada
+ *   tool call, e também sai do contexto que o modelo vê: a identidade vem do harness, nunca do
+ *   texto.
+ *
+ * Em produção (`eve start`, Vercel) o acesso local não autentica nada e o canal se comporta como
+ * o padrão com os autenticadores que você passar.
+ */
+declare function labChannel(options?: LabChannelOptions): EveChannel;
+/** O `onMessage` do canal do lab (exportado para os testes e para canais montados à mão). */
+declare function labOnMessage(options: Pick<LabChannelOptions, "onMessage" | "connectorUrl">): (ctx: EveMessageContext, message: unknown) => Promise<EveMessageResult>;
+
+export { type LabChannelOptions, labChannel, labOnMessage };

package/dist/channel.js

@@ -0,0 +1,86 @@
+import {
+  LAB_ACCOUNT_ATTRIBUTE,
+  LAB_ACCOUNT_CONTEXT_KEY,
+  labAccountFromContext
+} from "./chunk-LQIDQBNW.js";
+import {
+  LAB_FORK_ATTRIBUTE,
+  LAB_FORK_CONTEXT_KEY,
+  fetchForkPlan,
+  forkIdFromContext
+} from "./chunk-3IQOFBSQ.js";
+
+// src/channel.ts
+import { localDev } from "eve/channels/auth";
+import {
+  defaultEveAuth,
+  eveChannel
+} from "eve/channels/eve";
+function labChannel(options = {}) {
+  const { auth, connectorUrl, onMessage, ...rest } = options;
+  const own = auth === void 0 ? [] : Array.isArray(auth) ? auth : [auth];
+  return eveChannel({
+    ...rest,
+    auth: [...own, labLocalDev()],
+    onMessage: labOnMessage({ onMessage, connectorUrl })
+  });
+}
+function labOnMessage(options) {
+  return async (ctx, message) => {
+    const base = options.onMessage ? await options.onMessage(ctx, message) : { auth: defaultEveAuth(ctx) };
+    const context = ctx.eve.clientContext;
+    const forkId = forkIdFromContext(context);
+    const account = labAccountFromContext(context);
+    if (!forkId && !account && !hasLabKeys(context)) return base;
+    const plan = forkId ? await fetchForkPlan(forkId, options.connectorUrl) : void 0;
+    const attributes = {
+      ...forkId ? { [LAB_FORK_ATTRIBUTE]: forkId } : {},
+      ...account ? { [LAB_ACCOUNT_ATTRIBUTE]: JSON.stringify(account) } : {}
+    };
+    return {
+      ...base,
+      auth: withAttributes(base.auth, attributes, account),
+      ...plan ? { history: [...plan.history, ...base.history ?? []] } : {},
+      clientContext: base.clientContext ?? withoutLabKeys(context)
+    };
+  };
+}
+function withAttributes(auth, attributes, account) {
+  if (Object.keys(attributes).length === 0) return auth;
+  if (auth) return { ...auth, attributes: { ...auth.attributes, ...attributes } };
+  if (!account) return auth;
+  return {
+    authenticator: "agent-builder-lab",
+    principalId: `lab-account:${account.id}`,
+    principalType: "user",
+    attributes
+  };
+}
+function labLocalDev() {
+  const local = localDev();
+  return async (request) => {
+    const caller = await local(request);
+    if (!caller) return caller;
+    return isLoopback(request) ? { ...caller, allowToolStubs: true } : caller;
+  };
+}
+function isLoopback(request) {
+  const host = new URL(request.url).hostname.replace(/^\[|\]$/g, "");
+  return host === "127.0.0.1" || host === "localhost" || host === "::1";
+}
+var LAB_KEYS = [LAB_FORK_CONTEXT_KEY, LAB_ACCOUNT_CONTEXT_KEY];
+function hasLabKeys(context) {
+  if (!context || typeof context !== "object" || Array.isArray(context)) return false;
+  return LAB_KEYS.some((key) => key in context);
+}
+function withoutLabKeys(context) {
+  if (!context || typeof context !== "object" || Array.isArray(context)) return [];
+  const others = Object.fromEntries(
+    Object.entries(context).filter(([key]) => !LAB_KEYS.includes(key))
+  );
+  return Object.keys(others).length > 0 ? others : [];
+}
+export {
+  labChannel,
+  labOnMessage
+};

package/dist/chunk-3IQOFBSQ.js

@@ -0,0 +1,82 @@
+// src/fork.ts
+var DEFAULT_CONNECTOR_URL = "http://127.0.0.1:2100";
+var LAB_FORK_CONTEXT_KEY = "labFork";
+var LAB_FORK_ATTRIBUTE = "labForkId";
+var REPLAY_PROVIDER = "lab-replay";
+function connectorUrl(explicit) {
+  return (explicit ?? process.env.LAB_CONNECTOR_URL ?? DEFAULT_CONNECTOR_URL).replace(/\/+$/, "");
+}
+function forkIdFromContext(context) {
+  if (!context || typeof context !== "object" || Array.isArray(context)) return void 0;
+  const fork = context[LAB_FORK_CONTEXT_KEY];
+  if (!fork || typeof fork !== "object") return void 0;
+  const id = fork.id;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+var TTL_MS = 10 * 60 * 1e3;
+var MAX_CACHED = 50;
+var cache = /* @__PURE__ */ new Map();
+function fetchForkPlan(forkId, baseUrl) {
+  const hit = cache.get(forkId);
+  if (hit && Date.now() - hit.at < TTL_MS) return hit.plan;
+  const plan = load(forkId, connectorUrl(baseUrl));
+  cache.set(forkId, { at: Date.now(), plan });
+  plan.catch(() => cache.delete(forkId));
+  if (cache.size > MAX_CACHED) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+  return plan;
+}
+async function load(forkId, base) {
+  let response;
+  try {
+    response = await fetch(`${base}/forks/${encodeURIComponent(forkId)}`, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(1e4)
+    });
+  } catch {
+    throw new Error(
+      `Agent Builder Lab: o conector n\xE3o respondeu em ${base}. Ele est\xE1 rodando (agent-builder-lab connect)?`
+    );
+  }
+  const body = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(`Agent Builder Lab: o lab n\xE3o entregou o fork ${forkId} (${response.status}).`);
+  }
+  return readPlan(body, forkId);
+}
+function readPlan(body, forkId) {
+  const root = body ?? {};
+  const history = Array.isArray(root.history) ? root.history.flatMap((m) => {
+    const e = m ?? {};
+    const role = e.role === "user" || e.role === "assistant" ? e.role : void 0;
+    const text = typeof e.text === "string" ? e.text : "";
+    if (!role || !text.trim()) return [];
+    return [{ role, text, ...typeof e.id === "string" && e.id ? { id: e.id } : {} }];
+  }) : [];
+  const replayRoot = root.replay;
+  const steps = Array.isArray(replayRoot?.steps) ? replayRoot.steps : void 0;
+  return {
+    forkId,
+    history,
+    ...steps ? {
+      replay: {
+        modelId: typeof replayRoot?.modelId === "string" ? replayRoot.modelId : void 0,
+        steps: steps.map((s) => ({
+          text: typeof s?.text === "string" ? s.text : void 0,
+          toolCalls: Array.isArray(s?.toolCalls) ? s.toolCalls : [],
+          usage: s?.usage
+        }))
+      }
+    } : {}
+  };
+}
+
+export {
+  LAB_FORK_CONTEXT_KEY,
+  LAB_FORK_ATTRIBUTE,
+  REPLAY_PROVIDER,
+  forkIdFromContext,
+  fetchForkPlan
+};

package/dist/chunk-LQIDQBNW.js

@@ -0,0 +1,80 @@
+// src/authorization.ts
+var LAB_ACCOUNT_CONTEXT_KEY = "labAccount";
+var LAB_ACCOUNT_ATTRIBUTE = "labAccount";
+var isStrings = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
+function readLabAccount(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const v = value;
+  if (v.v !== 1 || typeof v.id !== "string" || !v.id || !isStrings(v.grants)) return void 0;
+  const labels = {};
+  if (v.labels && typeof v.labels === "object" && !Array.isArray(v.labels)) {
+    for (const [key, label] of Object.entries(v.labels)) {
+      if (typeof label === "string") labels[key] = label;
+    }
+  }
+  return {
+    v: 1,
+    id: v.id,
+    name: typeof v.name === "string" && v.name ? v.name : v.id,
+    role: typeof v.role === "string" ? v.role : "",
+    roleName: typeof v.roleName === "string" && v.roleName ? v.roleName : String(v.role ?? ""),
+    grants: v.grants,
+    labels,
+    ...typeof v.patientId === "string" && v.patientId ? { patientId: v.patientId } : {}
+  };
+}
+function labAccountFromContext(context) {
+  if (!context || typeof context !== "object" || Array.isArray(context)) return void 0;
+  return readLabAccount(context[LAB_ACCOUNT_CONTEXT_KEY]);
+}
+function labAccountFromAuth(auth) {
+  const raw = auth?.attributes?.[LAB_ACCOUNT_ATTRIBUTE];
+  if (typeof raw !== "string") return void 0;
+  try {
+    return readLabAccount(JSON.parse(raw));
+  } catch {
+    return void 0;
+  }
+}
+function labAccountOf(ctx) {
+  return labAccountFromAuth(ctx.session.auth.current);
+}
+function labDenialReason(account, resource) {
+  const label = account.labels[resource] ?? resource.replace(/^[a-z]+:/, "");
+  return `403 Proibido: ${account.name} (${account.roleName}) n\xE3o tem acesso a ${label} (${resource}). O harness negou antes de executar.`;
+}
+var dataId = (name) => name.includes(":") ? name : `data:${name}`;
+function requiredResources(toolName, input, options = {}) {
+  const needTool = options.tool ?? !options.agent;
+  const data = typeof options.data === "function" ? options.data(input) : options.data ?? [];
+  return [
+    ...options.agent ? [`agent:${options.agent}`] : [],
+    ...needTool ? [`tool:${toolName}`] : [],
+    ...data.map(dataId)
+  ];
+}
+function labAuthorization(options = {}) {
+  return (ctx) => {
+    const account = labAccountOf(ctx);
+    if (account) {
+      const input = ctx.toolInput;
+      const missing = requiredResources(ctx.toolName, input, options).find(
+        (id) => !account.grants.includes(id)
+      );
+      if (missing) return { type: "denied", reason: labDenialReason(account, missing) };
+    }
+    return options.next ? options.next(ctx) : "not-applicable";
+  };
+}
+
+export {
+  LAB_ACCOUNT_CONTEXT_KEY,
+  LAB_ACCOUNT_ATTRIBUTE,
+  readLabAccount,
+  labAccountFromContext,
+  labAccountFromAuth,
+  labAccountOf,
+  labDenialReason,
+  requiredResources,
+  labAuthorization
+};

package/dist/index.d.ts

@@ -0,0 +1,128 @@
+import { InstrumentationProvider } from 'eve/instrumentation';
+
+/** A tool call do agente pai que abriu uma sessão de subagente. */
+interface KitParentLineage {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    subagentName?: string;
+}
+/** Tokens de uma chamada ao modelo, como o eve informa (campo ausente quando o provedor omite). */
+interface KitUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    inputTokenDetails?: {
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+    };
+    costUsd?: number;
+}
+interface KitError {
+    name?: string;
+    message: string;
+}
+/** Identidade comum a todo evento, para o lab casar com o stream NDJSON do eve. */
+interface KitEventBase {
+    /** Versão deste formato. */
+    v: 1;
+    /** Liga o início ao fim da mesma operação; estável entre replays do eve. */
+    idempotencyKey: string;
+    /** Ordem de envio neste processo do agente. */
+    seq: number;
+    /** Quando a instrumentação recebeu o evento (ISO 8601). */
+    at: string;
+    sessionId: string;
+    rootSessionId?: string;
+    turnId: string;
+    stepIndex: number;
+    /** Tentativa do step (retentativas do mesmo step têm o mesmo `stepIndex`). */
+    attemptIndex: number;
+    /** Nome do agente dono da sessão (o raiz ou o subagente), quando o kit viu a sessão começar. */
+    agentName?: string;
+    /** Só em sessões de subagente. */
+    parentLineage?: KitParentLineage;
+}
+interface KitModelCallStarted extends KitEventBase {
+    type: "model.call.started";
+    model: {
+        modelId: string;
+        provider: string;
+    };
+    /** O payload final enviado ao modelo. Ausente se a política de trace não liberar entradas. */
+    input?: {
+        instructions?: unknown;
+        messages: unknown[];
+        tools?: unknown[];
+    };
+}
+interface KitModelCallCompleted extends KitEventBase {
+    type: "model.call.completed";
+    finishReason: string;
+    usage: KitUsage;
+    responseModelId?: string;
+    /** Texto, reasoning e tool calls da resposta. Ausente se a política não liberar saídas. */
+    content?: unknown[];
+}
+interface KitModelCallFailed extends KitEventBase {
+    type: "model.call.failed";
+    error?: KitError;
+}
+interface KitToolCallStarted extends KitEventBase {
+    type: "tool.call.started";
+    callId: string;
+    toolName: string;
+    /** "tool-call", "subagent-call", "remote-agent-call" ou "load-skill". */
+    kind?: string;
+    input: unknown;
+    startedAtMs?: number;
+}
+interface KitToolCallCompleted extends KitEventBase {
+    type: "tool.call.completed";
+    /** Copiados do início da mesma operação; o eve não os repete no evento final. */
+    callId?: string;
+    toolName?: string;
+    outcome?: string;
+    output: {
+        type: "result";
+        output?: unknown;
+    } | {
+        type: "error";
+        error?: unknown;
+    };
+    durationMs?: number;
+    completedAtMs?: number;
+    /** Em chamadas a subagente, o uso do turno filho. */
+    usage?: KitUsage;
+}
+interface KitToolCallFailed extends KitEventBase {
+    type: "tool.call.failed";
+    callId?: string;
+    toolName?: string;
+    /** "failed", "rejected", "cancelled" ou "abandoned". */
+    outcome?: string;
+    errorCode?: string;
+    error?: KitError;
+    completedAtMs?: number;
+    usage?: KitUsage;
+}
+type KitEvent = KitModelCallStarted | KitModelCallCompleted | KitModelCallFailed | KitToolCallStarted | KitToolCallCompleted | KitToolCallFailed;
+type KitEventType = KitEvent["type"];
+
+declare const DEFAULT_KIT_URL = "http://127.0.0.1:2100/kit";
+interface LabInstrumentationOptions {
+    /** Entrada local do conector. Padrão: `LAB_KIT_URL` ou http://127.0.0.1:2100/kit. */
+    url?: string;
+    /** Tempo máximo de cada envio, em ms. */
+    timeoutMs?: number;
+    /** Manda também as saídas (resposta do modelo, resultado das tools). Padrão: sim. */
+    recordOutputs?: boolean;
+}
+/**
+ * Instrumentação do Agent Builder Lab para `agent/instrumentation/lab.ts`. Liga a captura das
+ * entradas e manda cada chamada ao modelo e cada tool call ao conector, com a identidade da
+ * sessão, do turno e do step para o lab casar com o stream. Se o conector não estiver ouvindo,
+ * os eventos são descartados sem afetar o agente.
+ */
+declare function labInstrumentation(options?: LabInstrumentationOptions): InstrumentationProvider;
+
+export { DEFAULT_KIT_URL, type KitError, type KitEvent, type KitEventBase, type KitEventType, type KitModelCallCompleted, type KitModelCallFailed, type KitModelCallStarted, type KitParentLineage, type KitToolCallCompleted, type KitToolCallFailed, type KitToolCallStarted, type KitUsage, type LabInstrumentationOptions, labInstrumentation };

package/dist/index.js

@@ -0,0 +1,238 @@
+// src/index.ts
+import {
+  defineInstrumentation
+} from "eve/instrumentation";
+
+// src/media.ts
+var DATA_URL = /^data:[^,]*;base64,/;
+var MEDIA_INLINE_LIMIT = 1024;
+function withoutInlineMedia(value, limit = MEDIA_INLINE_LIMIT) {
+  return strip(value, limit);
+}
+function strip(value, limit) {
+  if (typeof value === "string") {
+    if (value.length <= limit || !DATA_URL.test(value)) return value;
+    const payload = value.slice(value.indexOf(",") + 1);
+    return `[${Math.floor(payload.length * 3 / 4)} bytes]`;
+  }
+  if (Array.isArray(value)) {
+    let changed = false;
+    const out = value.map((item) => {
+      const next = strip(item, limit);
+      if (next !== item) changed = true;
+      return next;
+    });
+    return changed ? out : value;
+  }
+  if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    let changed = false;
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      const next = strip(item, limit);
+      if (next !== item) changed = true;
+      out[key] = next;
+    }
+    return changed ? out : value;
+  }
+  return value;
+}
+
+// src/sender.ts
+function createSender({ url, timeoutMs, maxPending }) {
+  let tail = Promise.resolve();
+  let pending = 0;
+  return {
+    send(event) {
+      if (pending >= maxPending) return;
+      pending += 1;
+      tail = tail.then(() => post(url, event, timeoutMs)).finally(() => {
+        pending -= 1;
+      });
+    },
+    async flush(limitMs) {
+      await Promise.race([tail, new Promise((resolve) => setTimeout(resolve, limitMs).unref())]);
+    }
+  };
+}
+async function post(url, event, timeoutMs) {
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(event, jsonSafe),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    await response.body?.cancel();
+  } catch {
+  }
+}
+function jsonSafe(_key, value) {
+  if (value instanceof Uint8Array) return `[${value.byteLength} bytes]`;
+  if (value instanceof ArrayBuffer) return `[${value.byteLength} bytes]`;
+  if (value instanceof URL) return value.href;
+  if (typeof value === "bigint") return value.toString();
+  return value;
+}
+
+// src/index.ts
+var DEFAULT_KIT_URL = "http://127.0.0.1:2100/kit";
+var MAX_SESSIONS = 500;
+function labInstrumentation(options = {}) {
+  const url = options.url ?? process.env.LAB_KIT_URL ?? DEFAULT_KIT_URL;
+  const recordOutputs = options.recordOutputs ?? true;
+  const sender = createSender({ url, timeoutMs: options.timeoutMs ?? 1e3, maxPending: 1e3 });
+  const sessions = /* @__PURE__ */ new Map();
+  let seq = 0;
+  function remember(sessionId, info) {
+    const known = sessions.get(sessionId);
+    sessions.delete(sessionId);
+    sessions.set(sessionId, {
+      agentName: info.agentName ?? known?.agentName,
+      parentLineage: info.parentLineage ? lineage(info.parentLineage) : known?.parentLineage
+    });
+    if (sessions.size > MAX_SESSIONS) {
+      const oldest = sessions.keys().next().value;
+      if (oldest !== void 0) sessions.delete(oldest);
+    }
+  }
+  function base(idempotencyKey, scope) {
+    const info = sessions.get(scope.sessionId);
+    seq += 1;
+    return {
+      v: 1,
+      idempotencyKey,
+      seq,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: scope.sessionId,
+      rootSessionId: scope.rootSessionId,
+      turnId: scope.turnId,
+      stepIndex: scope.stepIndex,
+      attemptIndex: scope.attemptIndex,
+      agentName: info?.agentName,
+      parentLineage: info?.parentLineage
+    };
+  }
+  function send(event) {
+    sender.send(event);
+  }
+  return defineInstrumentation({
+    tracePolicy: () => ({ emit: true, recordInputs: true, recordOutputs }),
+    events: {
+      "session.started": (event) => {
+        remember(event.sessionId, {
+          agentName: event.agentName,
+          parentLineage: event.parentLineage
+        });
+      },
+      "turn.started": (event) => {
+        remember(event.sessionId, {
+          agentName: event.agentName,
+          parentLineage: event.parentLineage
+        });
+      },
+      "model.call.started": (event) => {
+        send({
+          ...base(event.idempotencyKey, event.scope),
+          type: "model.call.started",
+          model: { modelId: event.model.modelId, provider: event.model.provider },
+          input: event.input && {
+            instructions: event.input.instructions,
+            messages: [...event.input.messages],
+            tools: event.input.tools && [...event.input.tools]
+          }
+        });
+      },
+      "model.call.completed": (event) => {
+        send({
+          ...base(event.idempotencyKey, event.scope),
+          type: "model.call.completed",
+          finishReason: event.finishReason,
+          usage: usage(event.usage),
+          responseModelId: event.responseModelId,
+          content: event.content && [...event.content]
+        });
+      },
+      "model.call.failed": (event) => {
+        send({
+          ...base(event.idempotencyKey, event.scope),
+          type: "model.call.failed",
+          error: error(event.error)
+        });
+      },
+      "tool.call.started": (event, ctx) => {
+        ctx.state.set({ callId: event.callId, toolName: event.toolName });
+        send({
+          ...base(event.idempotencyKey, event.scope),
+          type: "tool.call.started",
+          callId: event.callId,
+          toolName: event.toolName,
+          kind: event.kind,
+          input: event.input,
+          startedAtMs: event.startedAtMs
+        });
+      },
+      "tool.call.completed": (event, ctx) => {
+        const started = ctx.state.get();
+        send({
+          ...base(event.idempotencyKey, event.scope),
+          type: "tool.call.completed",
+          callId: started?.callId,
+          toolName: started?.toolName,
+          outcome: event.outcome,
+          // Prévias de imagem (data URLs) já chegam ao lab pelo stream do eve: aqui, só o tamanho.
+          output: withoutInlineMedia(event.output),
+          durationMs: event.durationMs,
+          completedAtMs: event.completedAtMs,
+          usage: event.usage && usage(event.usage)
+        });
+      },
+      "tool.call.failed": (event, ctx) => {
+        const started = ctx.state.get();
+        send({
+          ...base(event.idempotencyKey, event.scope),
+          type: "tool.call.failed",
+          callId: started?.callId,
+          toolName: started?.toolName,
+          outcome: event.outcome,
+          errorCode: event.errorCode,
+          error: error(event.error),
+          completedAtMs: event.completedAtMs,
+          usage: event.usage && usage(event.usage)
+        });
+      }
+    },
+    flush: () => sender.flush(2e3)
+  });
+}
+function lineage(value) {
+  return {
+    sessionId: value.sessionId,
+    turnId: value.turnId,
+    callId: value.callId,
+    subagentName: value.subagentName
+  };
+}
+function usage(value) {
+  return {
+    inputTokens: value.inputTokens,
+    outputTokens: value.outputTokens,
+    inputTokenDetails: value.inputTokenDetails && { ...value.inputTokenDetails },
+    costUsd: value.costUsd
+  };
+}
+function error(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (value instanceof Error) return { name: value.name, message: value.message };
+  if (typeof value === "object" && "message" in value) {
+    const record = value;
+    return {
+      name: typeof record.name === "string" ? record.name : void 0,
+      message: String(record.message)
+    };
+  }
+  return { message: String(value) };
+}
+export {
+  DEFAULT_KIT_URL,
+  labInstrumentation
+};

package/dist/replay.d.ts

@@ -0,0 +1,36 @@
+import * as eve from 'eve';
+import { AgentStaticModelDefinition, DynamicResolveContext } from 'eve';
+
+/** O modelo de verdade: fixo ou escolhido a cada step, como num `defineDynamic`. */
+type LabModelChoice = AgentStaticModelDefinition | {
+    model: AgentStaticModelDefinition;
+    modelContextWindowTokens?: number;
+    reasoning?: "provider-default" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+};
+type LabModelResolver = (event: unknown, ctx: DynamicResolveContext) => LabModelChoice | Promise<LabModelChoice>;
+interface LabReplayOptions {
+    /** Porta local do conector. Padrão: `LAB_CONNECTOR_URL` ou http://127.0.0.1:2100. */
+    connectorUrl?: string;
+    /**
+     * Janela informada ao eve nos steps repetidos (o `mockModel` não está no catálogo do AI
+     * Gateway, e o eve recusa um modelo dinâmico sem janela). Padrão: 1 milhão de tokens.
+     */
+    replayContextWindowTokens?: number;
+}
+/**
+ * Modelo do agente com replay para o Agent Builder Lab, para o `model` do `agent.ts`:
+ *
+ * ```ts
+ * import { labReplayModel } from "@agent-builder-lab/eve-kit/replay";
+ * export default defineAgent({ model: labReplayModel("anthropic/claude-sonnet-5.5") });
+ * ```
+ *
+ * Fora de um fork do lab, devolve o seu modelo em todo step. Num fork (o canal do lab marca o
+ * turno com o id), repete os steps gravados antes da volta editada, inclusive ela, com um
+ * `mockModel`: mesmo texto, mesmas tool calls e mesmos ids. Assim as voltas anteriores saem
+ * iguais às originais e o modelo de verdade só entra depois do ponto editado. O `modelId` desses
+ * steps é `lab-replay/<modelo original>`.
+ */
+declare function labReplayModel(model: LabModelChoice | LabModelResolver, options?: LabReplayOptions): eve.DynamicSentinel<LabModelChoice>;
+
+export { type LabModelChoice, type LabModelResolver, type LabReplayOptions, labReplayModel };

package/dist/replay.js

@@ -0,0 +1,50 @@
+import {
+  LAB_FORK_ATTRIBUTE,
+  REPLAY_PROVIDER,
+  fetchForkPlan
+} from "./chunk-3IQOFBSQ.js";
+
+// src/replay.ts
+import { defineDynamic } from "eve";
+import { mockModel } from "eve/evals";
+function labReplayModel(model, options = {}) {
+  const real = (event, ctx) => typeof model === "function" ? model(event, ctx) : model;
+  return defineDynamic({
+    events: {
+      "step.started": async (event, ctx) => {
+        const forkId = ctx.session.auth.current?.attributes[LAB_FORK_ATTRIBUTE];
+        if (typeof forkId !== "string") return real(event, ctx);
+        const plan = await fetchForkPlan(forkId, options.connectorUrl).catch(() => void 0);
+        const step = plan?.replay?.steps[stepIndexOf(event)];
+        if (!step) return real(event, ctx);
+        return {
+          model: replayStep(step, plan?.replay?.modelId),
+          modelContextWindowTokens: options.replayContextWindowTokens ?? 1e6
+        };
+      }
+    }
+  });
+}
+function stepIndexOf(event) {
+  const record = event ?? {};
+  const index = record.data?.stepIndex ?? record.stepIndex;
+  return typeof index === "number" ? index : -1;
+}
+function replayStep(step, modelId = "modelo") {
+  return mockModel({
+    provider: REPLAY_PROVIDER,
+    modelId,
+    respond: () => ({
+      text: step.text || void 0,
+      toolCalls: step.toolCalls.map((call) => ({
+        id: call.id,
+        name: call.name,
+        input: call.input
+      })),
+      usage: step.usage
+    })
+  });
+}
+export {
+  labReplayModel
+};

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@agent-builder-lab/eve-kit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Liga um agente eve ao Agent Builder Lab: instrumentação da janela de contexto, canal com history e stubs, replay e autorização por conta de teste.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./authorization": {
+      "types": "./dist/authorization.d.ts",
+      "import": "./dist/authorization.js"
+    },
+    "./channel": {
+      "types": "./dist/channel.d.ts",
+      "import": "./dist/channel.js"
+    },
+    "./replay": {
+      "types": "./dist/replay.d.ts",
+      "import": "./dist/replay.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "eve": "^0.83.2"
+  },
+  "devDependencies": {
+    "@types/node": "24.19.2",
+    "eve": "0.83.2",
+    "tsup": "8.5.1",
+    "typescript": "6.0.3",
+    "vitest": "5.0.5",
+    "@lab/config": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.