@hachej/boring-agent 0.1.77 → 0.1.79

package/dist/chunk-LCEBDU6G.js

@@ -0,0 +1,531 @@
+import {
+  AgentNotImplementedError
+} from "./chunk-WSQ5QNIY.js";
+import {
+  ErrorCode
+} from "./chunk-YVON2BHN.js";
+
+// src/core/createAgent.ts
+var DEFAULT_LIVE_BUFFER_SIZE = 1e3;
+function createAgent(config) {
+  return createAgentRuntimeBridge(config).agent;
+}
+function createAgentRuntimeBridge(config) {
+  const runtimeLoader = createRuntimeLoader(config.runtimeFactory);
+  const live = new AgentLiveEventBuffer(DEFAULT_LIVE_BUFFER_SIZE);
+  const sessionContexts = /* @__PURE__ */ new Map();
+  const startedSessions = /* @__PURE__ */ new Map();
+  const sendLocks = /* @__PURE__ */ new Map();
+  const producerTeardownLocks = /* @__PURE__ */ new Map();
+  let disposed = false;
+  let disposePromise;
+  const assertActive = () => {
+    if (disposed) {
+      throw stableAgentError(ErrorCode.enum.AGENT_BINDING_DISPOSED, "agent binding has been disposed");
+    }
+  };
+  const getRuntime = async () => {
+    assertActive();
+    const runtime = await runtimeLoader.get();
+    assertActive();
+    return runtime;
+  };
+  const sessions = createFacadeSessionStore(
+    getRuntime,
+    assertActive,
+    live,
+    sessionContexts,
+    startedSessions,
+    runProducerTeardown
+  );
+  const readiness = createReadiness(config, assertActive);
+  async function ensureSession(input, runtime) {
+    if (input.sessionId) {
+      const ctx = await authorizeSessionAccess(runtime, input.sessionId, input.ctx, sessionContexts);
+      return { sessionId: input.sessionId, sessionKey: sessionCacheKey(input.sessionId, ctx), ctx };
+    }
+    const service = runtime.service;
+    const created = await service.createSession(toPiRequestContext(input.ctx), {
+      title: contentToText(input.content ?? input.message).slice(0, 80) || void 0
+    });
+    rememberSessionCtx(sessionContexts, created.id, input.ctx);
+    return { sessionId: created.id, sessionKey: sessionCacheKey(created.id, input.ctx), ctx: input.ctx };
+  }
+  async function ensureBridge(sessionKey, sessionId, ctx, service) {
+    const state = live.ensure(sessionKey);
+    if (state.bridge || state.closed) return state;
+    state.bridgePromise ??= (async () => {
+      const subscribeFrom = state.latestIndex === 0 ? 0 : Number.MAX_SAFE_INTEGER;
+      let result = await service.subscribe(toPiRequestContext(ctx), sessionId, subscribeFrom, (chunk) => {
+        if (!state.closed) live.publish(sessionKey, sessionId, chunk);
+      });
+      if (result.type !== "ok") {
+        result = await service.subscribe(toPiRequestContext(ctx), sessionId, result.latestSeq, (chunk) => {
+          if (!state.closed) live.publish(sessionKey, sessionId, chunk);
+        });
+      }
+      if (result.type !== "ok") throw new AgentNotImplementedError("Historical pi-chat replay is not implemented until T1.");
+      if (disposed || state.closed) {
+        result.unsubscribe();
+        if (disposed) assertActive();
+        throw stableAgentError(ErrorCode.enum.ABORTED, "session stopped while start was pending");
+      }
+      state.bridge = result;
+      result.closed?.finally(() => live.close(sessionKey, state)).catch(() => live.close(sessionKey, state));
+      return state;
+    })();
+    try {
+      return await state.bridgePromise;
+    } finally {
+      state.bridgePromise = void 0;
+    }
+  }
+  async function start(input) {
+    assertActive();
+    const runtime = await getRuntime();
+    const { sessionId, sessionKey, ctx } = await ensureSession(input, runtime);
+    assertActive();
+    startedSessions.set(sessionKey, { sessionId, ctx });
+    await ensureBridge(sessionKey, sessionId, ctx, runtime.service);
+    assertActive();
+    const startIndex = live.latestIndex(sessionKey);
+    await runtime.service.prompt(toPiRequestContext(ctx), sessionId, toPromptPayload(input));
+    assertActive();
+    return { sessionId, startIndex };
+  }
+  const agent = {
+    sessions,
+    readiness,
+    start,
+    stream(sessionId, options) {
+      assertActive();
+      return authorizedStream(sessionId, options);
+    },
+    async *send(input) {
+      assertActive();
+      const release = input.sessionId ? await acquireSessionLock(sendLocks, sessionCacheKey(input.sessionId, input.ctx)) : void 0;
+      try {
+        assertActive();
+        const receipt = await start(input);
+        let turnId;
+        for await (const event of authorizedStream(receipt.sessionId, { startIndex: receipt.startIndex, ctx: input.ctx })) {
+          yield event;
+          if (event.chunk.type === "agent-start") turnId = event.chunk.turnId;
+          if (isSendTerminalEvent(event, turnId)) break;
+        }
+      } finally {
+        release?.();
+      }
+    },
+    async resolveInput(_sessionId, _requestId, _response) {
+      assertActive();
+      throw new AgentNotImplementedError("resolveInput is not implemented until T1.");
+    },
+    async interrupt(sessionId, ctx) {
+      assertActive();
+      const runtime = await getRuntime();
+      const accessCtx = await authorizeSessionAccess(runtime, sessionId, ctx, sessionContexts);
+      assertActive();
+      return runtime.service.interrupt(toPiRequestContext(accessCtx), sessionId, {});
+    },
+    async stop(sessionId, ctx) {
+      assertActive();
+      const runtime = await getRuntime();
+      const accessCtx = await authorizeSessionAccess(runtime, sessionId, ctx, sessionContexts);
+      assertActive();
+      const sessionKey = sessionCacheKey(sessionId, accessCtx);
+      return runProducerTeardown(sessionKey, async () => {
+        assertActive();
+        const receipt = await runtime.service.stop(toPiRequestContext(accessCtx), sessionId, {});
+        startedSessions.delete(sessionKey);
+        live.close(sessionKey);
+        return receipt;
+      });
+    },
+    dispose() {
+      disposed = true;
+      disposePromise ??= disposeBinding();
+      return disposePromise;
+    }
+  };
+  async function disposeBinding() {
+    const started = [...startedSessions.entries()];
+    let runtime;
+    let teardownError;
+    try {
+      runtime = await runtimeLoader.current();
+      if (runtime) {
+        const activeRuntime = runtime;
+        const results = await Promise.allSettled(started.map(
+          ([sessionKey, session]) => runProducerTeardown(sessionKey, async () => {
+            if (startedSessions.get(sessionKey) !== session) return;
+            await activeRuntime.service.stop(toPiRequestContext(session.ctx), session.sessionId, {});
+            startedSessions.delete(sessionKey);
+            live.close(sessionKey);
+          })
+        ));
+        const failed = results.find((result) => result.status === "rejected");
+        if (failed) throw failed.reason;
+      }
+    } catch (error) {
+      teardownError = error;
+    }
+    try {
+      await runtime?.service.dispose?.();
+    } catch (error) {
+      teardownError ??= error;
+    } finally {
+      try {
+        live.dispose();
+      } catch (error) {
+        teardownError ??= error;
+      } finally {
+        startedSessions.clear();
+        sessionContexts.clear();
+        sendLocks.clear();
+        producerTeardownLocks.clear();
+      }
+    }
+    if (teardownError) throw teardownError;
+  }
+  async function runProducerTeardown(sessionKey, teardown) {
+    const release = await acquireSessionLock(producerTeardownLocks, sessionKey);
+    try {
+      return await teardown();
+    } finally {
+      release();
+    }
+  }
+  return {
+    agent,
+    getRuntime,
+    currentRuntime() {
+      assertActive();
+      return runtimeLoader.current();
+    }
+  };
+  async function* authorizedStream(sessionId, options) {
+    assertActive();
+    const runtime = await getRuntime();
+    const accessCtx = await authorizeSessionAccess(runtime, sessionId, options.ctx, sessionContexts);
+    assertActive();
+    yield* live.stream(sessionCacheKey(sessionId, accessCtx), options.startIndex);
+  }
+}
+function createRuntimeLoader(runtimeFactory) {
+  let runtimePromise;
+  return {
+    get() {
+      runtimePromise ??= Promise.resolve().then(() => runtimeFactory());
+      return runtimePromise;
+    },
+    current() {
+      return runtimePromise;
+    }
+  };
+}
+function createReadiness(config, assertActive) {
+  const requirements = [...config.readinessRequirements ?? []];
+  return {
+    requirements,
+    async status() {
+      assertActive();
+      return requirements.map((key) => ({
+        key,
+        ready: false,
+        message: "readiness status is not available in the core facade"
+      }));
+    }
+  };
+}
+function createFacadeSessionStore(getRuntime, assertActive, live, sessionContexts, startedSessions, runProducerTeardown) {
+  const store = async () => (await getRuntime()).sessionStore;
+  return {
+    async list(ctx, options) {
+      assertActive();
+      const summaries = await (await store()).list(ctx, options);
+      assertActive();
+      return summaries.filter((summary) => canAccessStoredSessionCtx(summary.id, ctx, sessionContexts));
+    },
+    async create(ctx, init) {
+      assertActive();
+      const created = await (await store()).create(ctx, init);
+      assertActive();
+      rememberSessionCtx(sessionContexts, created.id, ctx);
+      return created;
+    },
+    async load(ctx, sessionId) {
+      assertActive();
+      const runtime = await getRuntime();
+      const accessCtx = await authorizeSessionAccess(runtime, sessionId, ctx, sessionContexts);
+      assertActive();
+      const loaded = await (await store()).load(accessCtx ?? {}, sessionId);
+      assertActive();
+      return loaded;
+    },
+    async delete(ctx, sessionId) {
+      assertActive();
+      const runtime = await getRuntime();
+      const accessCtx = await authorizeSessionAccess(runtime, sessionId, ctx, sessionContexts);
+      assertActive();
+      const sessionKey = sessionCacheKey(sessionId, accessCtx);
+      await runProducerTeardown(sessionKey, async () => {
+        assertActive();
+        await runtime.service.deleteSession(toPiRequestContext(accessCtx), sessionId);
+        startedSessions.delete(sessionKey);
+        live.close(sessionKey);
+        sessionContexts.delete(sessionKey);
+      });
+    }
+  };
+}
+function toPiRequestContext(ctx) {
+  return {
+    workspaceId: ctx?.workspaceId,
+    authSubject: ctx?.userId,
+    requestId: "agent-core"
+  };
+}
+function toPromptPayload(input) {
+  return {
+    message: contentToText(input.content ?? input.message),
+    clientNonce: `agent:${Date.now()}:${Math.random().toString(36).slice(2)}`,
+    ...input.model ? { model: input.model } : {},
+    ...input.thinkingLevel ? { thinkingLevel: input.thinkingLevel } : {},
+    ...input.attachments ? { attachments: input.attachments } : {}
+  };
+}
+function contentToText(content) {
+  if (content === void 0) return "";
+  if (typeof content === "string") return content;
+  return content.map((part) => part.text).filter((text) => typeof text === "string" && text.length > 0).join("\n");
+}
+async function loadSession(store, ctx, sessionId) {
+  try {
+    await store.load(ctx, sessionId);
+  } catch (error) {
+    throw normalizeSessionLoadError(error, sessionId);
+  }
+}
+async function assertLoadedSessionVisible(store, ctx, sessionId) {
+  const summaries = await store.list(ctx, { includeId: sessionId });
+  if (!summaries.some((summary) => summary.id === sessionId)) {
+    throw stableAgentError(ErrorCode.enum.UNAUTHORIZED, "session context mismatch");
+  }
+}
+function normalizeSessionLoadError(error, sessionId) {
+  if (error?.code === ErrorCode.enum.SESSION_NOT_FOUND || isPlainSessionNotFound(error, sessionId)) {
+    return stableAgentError(ErrorCode.enum.SESSION_NOT_FOUND, "session not found");
+  }
+  return error;
+}
+async function authorizeSessionAccess(runtime, sessionId, callerCtx, sessionContexts) {
+  const requestedKey = sessionCacheKey(sessionId, callerCtx);
+  const hasStoredCtx = sessionContexts.has(requestedKey);
+  const storedCtx = sessionContexts.get(requestedKey);
+  if (hasStoredCtx && callerCtx && !sameSessionCtx(callerCtx, storedCtx)) {
+    throw stableAgentError(ErrorCode.enum.UNAUTHORIZED, "session context mismatch");
+  }
+  if (hasStoredCtx && !callerCtx && !isEmptySessionCtx(storedCtx)) {
+    throw stableAgentError(ErrorCode.enum.UNAUTHORIZED, "session context required");
+  }
+  const accessCtx = callerCtx ?? storedCtx ?? {};
+  await loadSession(runtime.sessionStore, accessCtx, sessionId);
+  if (!hasStoredCtx) {
+    await assertLoadedSessionVisible(runtime.sessionStore, accessCtx, sessionId);
+    rememberSessionCtx(sessionContexts, sessionId, accessCtx);
+  }
+  return accessCtx;
+}
+function rememberSessionCtx(sessionContexts, sessionId, ctx) {
+  sessionContexts.set(sessionCacheKey(sessionId, ctx), isEmptySessionCtx(ctx) ? void 0 : { workspaceId: ctx?.workspaceId, userId: ctx?.userId });
+}
+function sameSessionCtx(a, b) {
+  return (a?.workspaceId ?? "") === (b?.workspaceId ?? "") && (a?.userId ?? "") === (b?.userId ?? "");
+}
+function isEmptySessionCtx(ctx) {
+  return !ctx?.workspaceId && !ctx?.userId;
+}
+function canAccessStoredSessionCtx(sessionId, callerCtx, sessionContexts) {
+  const sessionKey = sessionCacheKey(sessionId, callerCtx);
+  if (!sessionContexts.has(sessionKey)) return true;
+  const storedCtx = sessionContexts.get(sessionKey);
+  return sameSessionCtx(callerCtx, storedCtx);
+}
+function sessionCacheKey(sessionId, ctx) {
+  return JSON.stringify([sessionId, ctx?.workspaceId ?? "", ctx?.userId ?? ""]);
+}
+function stableAgentError(code, message) {
+  return Object.assign(new Error(message), { code });
+}
+async function acquireSessionLock(locks, sessionId) {
+  const previous = locks.get(sessionId) ?? Promise.resolve();
+  let release;
+  const current = previous.catch(() => {
+  }).then(() => new Promise((resolve) => {
+    release = resolve;
+  }));
+  locks.set(sessionId, current);
+  await previous.catch(() => {
+  });
+  return () => {
+    release();
+    if (locks.get(sessionId) === current) locks.delete(sessionId);
+  };
+}
+function isPlainSessionNotFound(error, sessionId) {
+  return error instanceof Error && (error.message === "session not found" || error.message === `Session not found: ${sessionId}` || error.message === `missing session ${sessionId}`);
+}
+function isSendTerminalEvent(event, turnId) {
+  const chunk = event.chunk;
+  if (chunk.type === "error") return !chunk.turnId || chunk.turnId === turnId;
+  return chunk.type === "agent-end" && chunk.willRetry !== true && chunk.turnId === turnId;
+}
+var AgentLiveEventBuffer = class {
+  constructor(maxEvents) {
+    this.maxEvents = maxEvents;
+  }
+  maxEvents;
+  sessions = /* @__PURE__ */ new Map();
+  eventIndexes = /* @__PURE__ */ new Map();
+  disposed = false;
+  latestIndex(sessionKey) {
+    return this.eventIndexes.get(sessionKey) ?? 0;
+  }
+  ensure(sessionKey) {
+    let state = this.sessions.get(sessionKey);
+    if (!state || state.closed) {
+      const latestIndex = this.latestIndex(sessionKey);
+      state = {
+        events: [],
+        subscribers: /* @__PURE__ */ new Set(),
+        latestIndex,
+        evictedThroughIndex: latestIndex - 1,
+        closed: false
+      };
+      this.sessions.set(sessionKey, state);
+    }
+    return state;
+  }
+  publish(sessionKey, sessionId, chunk) {
+    if (this.disposed) return;
+    const state = this.ensure(sessionKey);
+    if (state.closed) return;
+    const eventIndex = this.latestIndex(sessionKey);
+    this.eventIndexes.set(sessionKey, eventIndex + 1);
+    const event = {
+      v: 1,
+      eventIndex,
+      timestamp: Date.now(),
+      sessionId,
+      chunk
+    };
+    state.latestIndex = event.eventIndex + 1;
+    state.events.push(event);
+    if (state.events.length > this.maxEvents) {
+      const evicted = state.events.splice(0, state.events.length - this.maxEvents);
+      state.evictedThroughIndex = evicted[evicted.length - 1]?.eventIndex ?? state.evictedThroughIndex;
+    }
+    for (const subscriber of state.subscribers) subscriber.push(event);
+  }
+  stream(sessionKey, startIndex) {
+    const state = this.ensure(sessionKey);
+    this.assertReplayable(state, startIndex);
+    return {
+      [Symbol.asyncIterator]: () => {
+        this.assertReplayable(state, startIndex);
+        return createLiveIterator(state, startIndex);
+      }
+    };
+  }
+  close(sessionKey, expectedState) {
+    const state = this.sessions.get(sessionKey);
+    if (!state || expectedState && state !== expectedState) return;
+    state.closed = true;
+    let unsubscribeError;
+    try {
+      state.bridge?.unsubscribe();
+    } catch (error) {
+      unsubscribeError = error;
+    }
+    for (const subscriber of state.subscribers) subscriber.close();
+    state.subscribers.clear();
+    if (unsubscribeError) throw unsubscribeError;
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    let disposeError;
+    for (const [sessionId] of this.sessions) {
+      try {
+        this.close(sessionId);
+      } catch (error) {
+        disposeError ??= error;
+      }
+    }
+    this.sessions.clear();
+    this.eventIndexes.clear();
+    if (disposeError) throw disposeError;
+  }
+  assertReplayable(state, startIndex) {
+    if (!Number.isInteger(startIndex) || startIndex < 0) {
+      throw cursorOutOfRangeError("startIndex must be a non-negative integer", {
+        startIndex,
+        latestIndex: state.latestIndex
+      });
+    }
+    if (startIndex <= state.evictedThroughIndex) {
+      throw new AgentNotImplementedError("Historical stream replay is not implemented until T1.");
+    }
+    if (startIndex > state.latestIndex) {
+      throw cursorOutOfRangeError(`startIndex ${startIndex} is ahead of next eventIndex ${state.latestIndex}`, {
+        startIndex,
+        latestIndex: state.latestIndex
+      });
+    }
+  }
+};
+function cursorOutOfRangeError(message, details) {
+  return Object.assign(new RangeError(message), {
+    code: ErrorCode.enum.CURSOR_OUT_OF_RANGE,
+    details
+  });
+}
+function createLiveIterator(state, startIndex) {
+  const queued = [];
+  const waiters = [];
+  let active = true;
+  const subscriber = {
+    push(event) {
+      if (!active) return;
+      const waiter = waiters.shift();
+      if (waiter) waiter({ value: event, done: false });
+      else queued.push(event);
+    },
+    close() {
+      if (!active) return;
+      active = false;
+      while (waiters.length > 0) waiters.shift()?.({ value: void 0, done: true });
+    }
+  };
+  state.subscribers.add(subscriber);
+  queued.push(...state.events.filter((event) => event.eventIndex >= startIndex));
+  return {
+    async next() {
+      if (queued.length > 0) return { value: queued.shift(), done: false };
+      if (!active || state.closed) return { value: void 0, done: true };
+      return new Promise((resolve) => waiters.push(resolve));
+    },
+    async return() {
+      active = false;
+      state.subscribers.delete(subscriber);
+      while (waiters.length > 0) waiters.shift()?.({ value: void 0, done: true });
+      return { value: void 0, done: true };
+    }
+  };
+}
+
+export {
+  createAgent,
+  createAgentRuntimeBridge
+};

package/dist/{chunk-ORURYKNY.js → chunk-P23XFC4W.js}

@@ -1,6 +1,6 @@
 import {
   ErrorCode
-} from "./chunk-6AEK34XU.js";
+} from "./chunk-YVON2BHN.js";
 
 // src/shared/tool-ui.ts
 function isRecord(value) {