@hachej/boring-agent 0.1.111 → 0.2.1

package/dist/core/index.js

@@ -1,617 +0,0 @@
-import {
-  AGENT_NOT_IMPLEMENTED_UNTIL_T1,
-  AgentNotImplementedError
-} from "../chunk-YTUZFKB3.js";
-import {
-  ErrorCode
-} from "../chunk-KJIEMSQP.js";
-
-// src/core/piChatSessionService.ts
-var AgentEffectAdmissionError = class extends Error {
-  constructor(code, details) {
-    super(code);
-    this.code = code;
-    this.details = details;
-    this.name = "AgentEffectAdmissionError";
-  }
-  code;
-  details;
-  statusCode = 500;
-};
-var observedSynchronousServiceErrors = /* @__PURE__ */ new WeakSet();
-function invokeObservedServiceEffect(effect) {
-  try {
-    return effect();
-  } catch (error) {
-    if (typeof error === "object" && error !== null || typeof error === "function") {
-      observedSynchronousServiceErrors.add(error);
-    }
-    throw error;
-  }
-}
-var AGENT_EFFECT_METHODS = {
-  createSession: true,
-  deleteSession: true,
-  prompt: true,
-  followUp: true,
-  clearQueue: true,
-  interrupt: true,
-  stop: true
-};
-function withAgentEffectAdmission(service, admit) {
-  return {
-    ...service.resolveSessionStreamPath ? { resolveSessionStreamPath: (ctx, sessionId) => service.resolveSessionStreamPath(ctx, sessionId) } : {},
-    ...service.ensurePiSessionBound ? { ensurePiSessionBound: (ctx, sessionId) => service.ensurePiSessionBound(ctx, sessionId) } : {},
-    ...service.listSessions ? { listSessions: (ctx, options) => service.listSessions(ctx, options) } : {},
-    async createSession(ctx, init) {
-      await admit(ctx);
-      return invokeObservedServiceEffect(() => service.createSession(ctx, init));
-    },
-    async deleteSession(ctx, sessionId) {
-      await admit(ctx);
-      return invokeObservedServiceEffect(() => service.deleteSession(ctx, sessionId));
-    },
-    ...service.readAttachment ? { readAttachment: (ctx, sessionId, messageId, index) => service.readAttachment(ctx, sessionId, messageId, index) } : {},
-    readState: (ctx, sessionId) => service.readState(ctx, sessionId),
-    subscribe: (ctx, sessionId, cursor, subscriber) => service.subscribe(ctx, sessionId, cursor, subscriber),
-    async prompt(ctx, sessionId, payload) {
-      await admit(ctx);
-      return invokeObservedServiceEffect(() => service.prompt(ctx, sessionId, payload));
-    },
-    async followUp(ctx, sessionId, payload) {
-      await admit(ctx);
-      return invokeObservedServiceEffect(() => service.followUp(ctx, sessionId, payload));
-    },
-    async clearQueue(ctx, sessionId, payload) {
-      await admit(ctx);
-      return invokeObservedServiceEffect(() => service.clearQueue(ctx, sessionId, payload));
-    },
-    async interrupt(ctx, sessionId, payload) {
-      await admit(ctx);
-      return invokeObservedServiceEffect(() => service.interrupt(ctx, sessionId, payload));
-    },
-    async stop(ctx, sessionId, payload) {
-      await admit(ctx);
-      return invokeObservedServiceEffect(() => service.stop(ctx, sessionId, payload));
-    },
-    ...service.dispose ? { dispose: () => service.dispose() } : {}
-  };
-}
-
-// src/core/createAgent.ts
-var DEFAULT_LIVE_BUFFER_SIZE = 1e3;
-function createAgent(config) {
-  return createAgentRuntimeBridge(config).agent;
-}
-function createAgentRuntimeBridge(config) {
-  const runtimeLoader = createRuntimeLoader(async () => {
-    const runtime = await config.runtimeFactory();
-    return config.admitEffect ? { ...runtime, service: withAgentEffectAdmission(runtime.service, config.admitEffect) } : runtime;
-  });
-  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 reporter = config.readiness;
-  const requirements = [...reporter?.requirements ?? config.readinessRequirements ?? []];
-  return {
-    requirements,
-    async status() {
-      assertActive();
-      if (!reporter) {
-        return requirements.map((key) => ({
-          key,
-          ready: false,
-          message: "readiness status is not available in the core facade"
-        }));
-      }
-      const statuses = await reporter.status();
-      assertActive();
-      return statuses;
-    }
-  };
-}
-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 runtime = await getRuntime();
-      const created = await runtime.service.createSession(toPiRequestContext(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 {
-  AGENT_EFFECT_METHODS,
-  AGENT_NOT_IMPLEMENTED_UNTIL_T1,
-  AgentEffectAdmissionError,
-  AgentNotImplementedError,
-  createAgent,
-  withAgentEffectAdmission
-};

package/dist/createHarness-DOLOHA62.js

@@ -1,18 +0,0 @@
-import {
-  createPiCodingAgentHarness,
-  createResourceSettingsManager,
-  deriveSourcePlugin,
-  mergePiPackageSources,
-  projectSkillResourceLocations,
-  withPiHarnessDefaults
-} from "./chunk-42D6KAQV.js";
-import "./chunk-7XAOVFSN.js";
-import "./chunk-KJIEMSQP.js";
-export {
-  createPiCodingAgentHarness,
-  createResourceSettingsManager,
-  deriveSourcePlugin,
-  mergePiPackageSources,
-  projectSkillResourceLocations,
-  withPiHarnessDefaults
-};