@openchambery/web 1.18.7-beta.2 → 1.18.7-beta.3

package/server/lib/scheduled-tasks/runtime.js

@@ -305,6 +305,113 @@ const extractGoalFromSession = (session) => {
   };
 };
 
+/**
+ * Single-shot session outcome for post-run continuation (no polling).
+ * Goal-enabled: terminal complete → success; blocked/budgetLimited → error;
+ * otherwise not-yet-success. Non-goal: busy/retry, assistant error, or
+ * completed assistant; incomplete/empty tails are not treated as success.
+ */
+const snapshotSessionOutcome = async ({
+  client,
+  sessionID,
+  projectPath,
+  goalEnabled,
+  signal,
+}) => {
+  const requestOptions = signal ? { signal } : undefined;
+
+  if (goalEnabled && typeof client?.session?.get === 'function') {
+    try {
+      const sessionResult = await client.session.get({
+        sessionID,
+        directory: projectPath,
+      }, requestOptions);
+      if (!sessionResult?.error) {
+        const goal = extractGoalFromSession(sessionResult?.data);
+        if (goal && GOAL_TERMINAL_STATUSES.has(goal.status)) {
+          if (goal.status === 'complete') {
+            return { outcome: 'success' };
+          }
+          return {
+            outcome: 'error',
+            error: goal.note || `goal ${goal.status}`,
+          };
+        }
+      }
+    } catch (error) {
+      if (signal?.aborted) throw error;
+    }
+    return { outcome: 'busy' };
+  }
+
+  if (typeof client?.session?.status === 'function') {
+    try {
+      const statusResult = await client.session.status({
+        directory: projectPath,
+      }, requestOptions);
+      if (!statusResult?.error && statusResult?.data && typeof statusResult.data === 'object') {
+        const statusValue = statusResult.data[sessionID];
+        const type = statusValue?.type ?? statusValue?.status;
+        if (type === 'busy' || type === 'retry') {
+          return { outcome: 'busy' };
+        }
+      }
+    } catch (error) {
+      if (signal?.aborted) throw error;
+    }
+  }
+
+  if (typeof client?.session?.messages === 'function') {
+    try {
+      const messagesResult = await client.session.messages({
+        sessionID,
+        directory: projectPath,
+        limit: 50,
+      }, requestOptions);
+      if (!messagesResult?.error && Array.isArray(messagesResult?.data)) {
+        const lastInfo = readMessageInfo(messagesResult.data.at(-1));
+        if (lastInfo?.role === 'assistant') {
+          if (lastInfo.error) {
+            return {
+              outcome: 'error',
+              error: formatAssistantError(lastInfo.error),
+            };
+          }
+          if (lastInfo.time?.completed) {
+            return { outcome: 'success' };
+          }
+        }
+      }
+    } catch (error) {
+      if (signal?.aborted) throw error;
+    }
+  }
+
+  return { outcome: 'busy' };
+};
+
+const parseSessionEventPhase = (event) => {
+  const payload = event?.payload?.payload ?? event?.payload;
+  const properties = payload?.properties;
+  const sessionID = typeof properties?.sessionID === 'string' ? properties.sessionID : '';
+  if (!sessionID) {
+    return { phase: '', sessionID: '' };
+  }
+  if (payload?.type === 'session.idle') {
+    return { phase: 'idle', sessionID };
+  }
+  if (payload?.type === 'session.status') {
+    const type = properties?.status?.type ?? properties?.info?.type;
+    if (type === 'idle') {
+      return { phase: 'idle', sessionID };
+    }
+    if (type === 'busy' || type === 'retry') {
+      return { phase: 'busy', sessionID };
+    }
+  }
+  return { phase: '', sessionID };
+};
+
 export const createScheduledTasksRuntime = (deps) => {
   const {
     projectConfigRuntime,
@@ -331,6 +438,34 @@ export const createScheduledTasksRuntime = (deps) => {
   const runningCountByProject = new Map();
   let runningGlobalCount = 0;
   const queue = [];
+  /** sessionID → { projectID, taskID } for post-run continuation correction. */
+  const lastSessionOwners = new Map();
+
+  const rememberLastSession = (projectID, task) => {
+    const sessionID = task?.state?.lastSessionId;
+    if (typeof sessionID !== 'string' || !sessionID || !task?.id) {
+      return;
+    }
+    lastSessionOwners.set(sessionID, { projectID, taskID: task.id });
+  };
+
+  const forgetLastSessionsForProject = (projectID) => {
+    for (const [sessionID, owner] of [...lastSessionOwners.entries()]) {
+      if (owner.projectID === projectID) {
+        lastSessionOwners.delete(sessionID);
+      }
+    }
+  };
+
+  const forgetLastSessionIfOwned = (projectID, taskID, sessionID) => {
+    if (typeof sessionID !== 'string' || !sessionID) {
+      return;
+    }
+    const owner = lastSessionOwners.get(sessionID);
+    if (owner?.projectID === projectID && owner?.taskID === taskID) {
+      lastSessionOwners.delete(sessionID);
+    }
+  };
 
   const clearTimerForKey = (taskKey) => {
     const timer = timersByTaskKey.get(taskKey);
@@ -361,9 +496,11 @@ export const createScheduledTasksRuntime = (deps) => {
 
   const setProjectTasks = (projectID, tasks) => {
     clearProjectTimers(projectID);
+    forgetLastSessionsForProject(projectID);
     const taskMap = new Map();
     for (const task of tasks) {
       taskMap.set(task.id, task);
+      rememberLastSession(projectID, task);
     }
     tasksByProject.set(projectID, taskMap);
   };
@@ -412,7 +549,14 @@ export const createScheduledTasksRuntime = (deps) => {
     if (!taskMap) {
       return;
     }
+    const previous = taskMap.get(nextTask.id);
+    const previousSessionID = previous?.state?.lastSessionId;
+    const nextSessionID = nextTask.state?.lastSessionId;
+    if (previousSessionID && previousSessionID !== nextSessionID) {
+      forgetLastSessionIfOwned(projectID, nextTask.id, previousSessionID);
+    }
     taskMap.set(nextTask.id, nextTask);
+    rememberLastSession(projectID, nextTask);
   };
 
   const syncTaskSchedule = async (projectID, task) => {
@@ -1152,6 +1296,15 @@ export const createScheduledTasksRuntime = (deps) => {
           if (runningState.task) {
             updateInMemoryTask(projectID, runningState.task);
           }
+          try {
+            emitTaskRunEvent?.({
+              projectID,
+              taskID,
+              ranAt: runStartedAt,
+              status: 'running',
+            });
+          } catch {
+          }
         } catch (error) {
           errorMessage = safeErrorMessage(error);
           logger.warn?.('[ScheduledTasks] failed to persist running state', {
@@ -1278,14 +1431,17 @@ export const createScheduledTasksRuntime = (deps) => {
 
       const nextRunAt = computeNextRunAt(latestTask, finishedAt);
       try {
-        stateResult = await projectConfigRuntime.updateScheduledTaskState(projectID, taskID, {
+        const statePatch = {
           lastStatus: status,
           lastDurationMs: durationMs,
           lastError: status === 'error' ? errorMessage : undefined,
-          lastSessionId: status === 'success' ? sessionID : undefined,
           nextRunAt: Number.isFinite(nextRunAt) ? nextRunAt : undefined,
           updatedAt: finishedAt,
-        });
+        };
+        if (sessionID) {
+          statePatch.lastSessionId = sessionID;
+        }
+        stateResult = await projectConfigRuntime.updateScheduledTaskState(projectID, taskID, statePatch);
         if (stateResult.task) {
           updateInMemoryTask(projectID, stateResult.task);
           if (stateResult.task.enabled && Number.isFinite(stateResult.task.state?.nextRunAt)) {
@@ -1301,6 +1457,9 @@ export const createScheduledTasksRuntime = (deps) => {
           error: errorMessage,
         });
       }
+      if (sessionID) {
+        lastSessionOwners.set(sessionID, { projectID, taskID });
+      }
 
       // History final status reflects the ultimate run outcome, including
       // state-persistence failures. A failed finalize leaves the row running
@@ -1441,6 +1600,114 @@ export const createScheduledTasksRuntime = (deps) => {
     };
   };
 
+  const emitContinuationStatus = (projectID, taskID, sessionID, status) => {
+    try {
+      emitTaskRunEvent?.({
+        projectID,
+        taskID,
+        ranAt: Date.now(),
+        status,
+        sessionID,
+      });
+    } catch {
+    }
+  };
+
+  const handleSessionContinuation = async (event) => {
+    const { phase, sessionID } = parseSessionEventPhase(event);
+    if (!phase || !sessionID) {
+      return;
+    }
+
+    const owner = lastSessionOwners.get(sessionID);
+    if (!owner) {
+      return;
+    }
+
+    const { projectID, taskID } = owner;
+    const taskKey = buildTaskKey(projectID, taskID);
+    if (runningTaskKeys.has(taskKey)) {
+      return;
+    }
+
+    const task = tasksByProject.get(projectID)?.get(taskID);
+    const lastStatus = task?.state?.lastStatus;
+
+    if (phase === 'busy') {
+      if (lastStatus !== 'error' && lastStatus !== 'success') {
+        return;
+      }
+      const stateResult = await projectConfigRuntime.updateScheduledTaskState(projectID, taskID, {
+        lastStatus: 'running',
+        lastError: undefined,
+        lastSessionId: sessionID,
+        updatedAt: Date.now(),
+      });
+      if (stateResult.task) {
+        updateInMemoryTask(projectID, stateResult.task);
+      }
+      emitContinuationStatus(projectID, taskID, sessionID, 'running');
+      return;
+    }
+
+    if (lastStatus === 'success') {
+      return;
+    }
+    if (lastStatus !== 'error' && lastStatus !== 'running') {
+      return;
+    }
+
+    const projectPath = projectPathByID.get(projectID) || await ensureProjectPath(projectID);
+    if (!projectPath) {
+      return;
+    }
+
+    const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
+    const authHeaders = getOpenCodeAuthHeaders();
+    const client = createOpencodeClient({
+      baseUrl,
+      headers: authHeaders,
+    });
+    const snapshot = await snapshotSessionOutcome({
+      client,
+      sessionID,
+      projectPath,
+      goalEnabled: Boolean(task.execution?.goalEnabled),
+    });
+    if (snapshot.outcome !== 'success') {
+      return;
+    }
+
+    if (runningTaskKeys.has(taskKey)) {
+      return;
+    }
+    const latest = tasksByProject.get(projectID)?.get(taskID);
+    const latestStatus = latest?.state?.lastStatus;
+    if (latestStatus !== 'error' && latestStatus !== 'running') {
+      return;
+    }
+
+    const stateResult = await projectConfigRuntime.updateScheduledTaskState(projectID, taskID, {
+      lastStatus: 'success',
+      lastError: undefined,
+      lastSessionId: sessionID,
+      updatedAt: Date.now(),
+    });
+    if (stateResult.task) {
+      updateInMemoryTask(projectID, stateResult.task);
+    }
+
+    emitContinuationStatus(projectID, taskID, sessionID, 'success');
+  };
+
+  const observeSessionEvent = (event) => {
+    return handleSessionContinuation(event).catch((error) => {
+      logger.warn?.('[ScheduledTasks] observeSessionEvent failed', {
+        error: safeErrorMessage(error),
+      });
+    });
+  };
+
   return {
     start,
     stop,
@@ -1448,5 +1715,6 @@ export const createScheduledTasksRuntime = (deps) => {
     syncProject,
     runNow,
     getStatus,
+    observeSessionEvent,
   };
 };

package/server/lib/scheduled-tasks/runtime.test.js

@@ -993,4 +993,312 @@ describe('scheduled-tasks run history and session lifecycle', () => {
 
     vi.unstubAllGlobals();
   });
+
+  it('persists lastSessionId when an error run still created a session', async () => {
+    const history = createHistoryStore();
+    createSuccessfulClient({ settlement: 'assistant-error' });
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe('error');
+    const finalPatch = updateScheduledTaskState.mock.calls.at(-1)[2];
+    expect(finalPatch.lastStatus).toBe('error');
+    expect(finalPatch.lastSessionId).toBe('ses_1');
+
+    vi.unstubAllGlobals();
+  });
+
+  it('omits lastSessionId from the final patch when the failed run has no session', async () => {
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState);
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe('error');
+    const finalPatch = updateScheduledTaskState.mock.calls.at(-1)[2];
+    expect(finalPatch.lastStatus).toBe('error');
+    expect(Object.hasOwn(finalPatch, 'lastSessionId')).toBe(false);
+  });
+
+  it('marks lastStatus running when a history session continues, then success on idle', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient({ settlement: 'assistant-error' });
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const emitTaskRunEvent = vi.fn();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      emitTaskRunEvent,
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+    expect(result.status).toBe('error');
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.status',
+        properties: { sessionID: 'ses_1', status: { type: 'busy' } },
+      },
+    });
+
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+    const runningPatch = updateScheduledTaskState.mock.calls.at(-1)[2];
+    expect(runningPatch).toEqual(expect.objectContaining({
+      lastStatus: 'running',
+      lastError: undefined,
+      lastSessionId: 'ses_1',
+    }));
+    expect(Object.hasOwn(runningPatch, 'lastRunAt')).toBe(false);
+    expect(emitTaskRunEvent).toHaveBeenCalledWith(expect.objectContaining({
+      projectID: 'project-1',
+      taskID: 'task-1',
+      status: 'running',
+      sessionID: 'ses_1',
+    }));
+
+    client.messages.mockImplementation(async () => ({
+      data: [{
+        info: {
+          id: 'msg_ok',
+          role: 'assistant',
+          time: { completed: Date.now() },
+        },
+      }],
+    }));
+
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.idle',
+        properties: { sessionID: 'ses_1' },
+      },
+    });
+
+    expect(updateScheduledTaskState.mock.calls.at(-1)[2]).toEqual(expect.objectContaining({
+      lastStatus: 'success',
+      lastSessionId: 'ses_1',
+    }));
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+
+    vi.unstubAllGlobals();
+  });
+
+  it('corrects lastStatus error → success on idle after a continuation, without rewriting history', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient({ settlement: 'assistant-error' });
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const emitTaskRunEvent = vi.fn();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      emitTaskRunEvent,
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+    expect(result.status).toBe('error');
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+
+    client.messages.mockImplementation(async () => ({
+      data: [{
+        info: {
+          id: 'msg_ok',
+          role: 'assistant',
+          time: { completed: Date.now() },
+        },
+      }],
+    }));
+
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.idle',
+        properties: { sessionID: 'ses_1' },
+      },
+    });
+
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+    const correctionPatch = updateScheduledTaskState.mock.calls.at(-1)[2];
+    expect(correctionPatch).toEqual(expect.objectContaining({
+      lastStatus: 'success',
+      lastError: undefined,
+      lastSessionId: 'ses_1',
+    }));
+    expect(Object.hasOwn(correctionPatch, 'lastRunAt')).toBe(false);
+    expect(Object.hasOwn(correctionPatch, 'lastDurationMs')).toBe(false);
+    expect(Object.hasOwn(correctionPatch, 'nextRunAt')).toBe(false);
+    expect(emitTaskRunEvent).toHaveBeenCalledWith(expect.objectContaining({
+      projectID: 'project-1',
+      taskID: 'task-1',
+      status: 'success',
+      sessionID: 'ses_1',
+    }));
+
+    vi.unstubAllGlobals();
+  });
+
+  it('does not correct lastStatus while the task is still running', async () => {
+    vi.useFakeTimers();
+    const history = createHistoryStore();
+    const erroredTask = {
+      ...scheduledTask,
+      state: {
+        ...scheduledTask.state,
+        lastStatus: 'error',
+        lastSessionId: 'ses_1',
+        lastError: 'ProviderError',
+      },
+    };
+    createSuccessfulClient({ settlement: 'busy-then-success' });
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const emitTaskRunEvent = vi.fn();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...erroredTask, state: { ...erroredTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      projectConfigRuntime: {
+        listScheduledTasks: vi.fn(async () => [erroredTask]),
+        updateScheduledTaskState,
+        upsertScheduledTask: vi.fn(),
+      },
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      emitTaskRunEvent,
+    });
+    await runtime.syncProject('project-1');
+
+    const runPromise = runtime.runNow('project-1', 'task-1');
+    await vi.advanceTimersByTimeAsync(0);
+    expect(history.finishRun).not.toHaveBeenCalled();
+
+    const successEmitsBefore = emitTaskRunEvent.mock.calls.filter((call) => call[0].status === 'success').length;
+    const continuationRunningBefore = updateScheduledTaskState.mock.calls.filter((call) => (
+      call[2].lastStatus === 'running' && !Object.hasOwn(call[2], 'lastRunAt')
+    )).length;
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.status',
+        properties: { sessionID: 'ses_1', status: { type: 'busy' } },
+      },
+    });
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.idle',
+        properties: { sessionID: 'ses_1' },
+      },
+    });
+    expect(history.finishRun).not.toHaveBeenCalled();
+    expect(updateScheduledTaskState.mock.calls.map((call) => call[2].lastStatus)).not.toContain('success');
+    expect(emitTaskRunEvent.mock.calls.filter((call) => call[0].status === 'success')).toHaveLength(successEmitsBefore);
+    expect(updateScheduledTaskState.mock.calls.filter((call) => (
+      call[2].lastStatus === 'running' && !Object.hasOwn(call[2], 'lastRunAt')
+    ))).toHaveLength(continuationRunningBefore);
+
+    await vi.advanceTimersByTimeAsync(1_000);
+    const result = await runPromise;
+    expect(result.ok).toBe(true);
+
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+  });
+
+  it('does not correct lastStatus when it is already success', async () => {
+    const history = createHistoryStore();
+    const client = createSuccessfulClient();
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('prompt_async')) {
+        return { ok: true, text: async () => '' };
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const emitTaskRunEvent = vi.fn();
+    const updateScheduledTaskState = vi.fn(async (_projectID, _taskID, state) => ({
+      task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+    }));
+    const runtime = createRuntime(updateScheduledTaskState, {
+      runHistoryStore: history,
+      waitForOpenCodeReady: vi.fn(async () => {}),
+      emitTaskRunEvent,
+    });
+    await runtime.syncProject('project-1');
+    const result = await runtime.runNow('project-1', 'task-1');
+
+    expect(result.ok).toBe(true);
+    expect(emitTaskRunEvent.mock.calls.map((call) => call[0].status)[0]).toBe('running');
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+    const stateWritesAfterRun = updateScheduledTaskState.mock.calls.length;
+    const successEmitsAfterRun = emitTaskRunEvent.mock.calls.filter((call) => call[0].status === 'success').length;
+
+    client.messages.mockImplementation(async () => ({
+      data: [{
+        info: {
+          id: 'msg_ok',
+          role: 'assistant',
+          time: { completed: Date.now() },
+        },
+      }],
+    }));
+
+    await runtime.observeSessionEvent({
+      payload: {
+        type: 'session.status',
+        properties: {
+          sessionID: 'ses_1',
+          status: { type: 'idle' },
+        },
+      },
+    });
+
+    expect(history.finishRun).toHaveBeenCalledTimes(1);
+    expect(updateScheduledTaskState).toHaveBeenCalledTimes(stateWritesAfterRun);
+    expect(emitTaskRunEvent.mock.calls.filter((call) => call[0].status === 'success')).toHaveLength(successEmitsAfterRun);
+
+    vi.unstubAllGlobals();
+  });
 });

package/server/lib/session-goal/runtime.js

@@ -111,8 +111,8 @@ const buildAuditSystemPrompt = () => [
 
 // Hard guard against language hallucination (account-side personalization
 // can leak a different language despite the instruction): if the note uses
-// a script absent from the objective and the agent's reply, drop the note
-// but keep the verdict.
+// a script absent from the objective
+// and the agent's reply, drop the note but keep the verdict.
 const SCRIPT_RANGES = [
   /[Ѐ-ӿ]/, // Cyrillic
   /[぀-ヿ一-鿿가-힯]/, // CJK

package/dist/assets/AgentAvatar-CWn_73qY.js

@@ -1 +0,0 @@
-import"./rolldown-runtime-C0FnF6B9.js";import{nt as e,rt as t}from"./vendor-base-ui-CnHfUmDN.js";import{n}from"./vendor-react-DLPElpoQ.js";import{t as r}from"./utils-CJdWZupK.js";t();var i=n(),a=[{var:`--status-success`,class:`agent-success`},{var:`--syntax-keyword`,class:`agent-keyword`},{var:`--syntax-type`,class:`agent-type`},{var:`--syntax-function`,class:`agent-function`},{var:`--syntax-number`,class:`agent-number`},{var:`--status-info`,class:`agent-info`},{var:`--status-warning`,class:`agent-warning`},{var:`--syntax-variable`,class:`agent-variable`}];function o(e){if(!e||e===`build`)return a[0];let t=0;for(let n=0;n<e.length;n++){let r=e.charCodeAt(n);t=(t<<5)-t+r,t&=t}return a[1+Math.abs(t)%(a.length-1)]}var s=5,c=Math.ceil(s/2);function l(e){let t=0;for(let n=0;n<e.length;n++)t=(t<<5)-t+e.charCodeAt(n),t|=0;return t>>>0}function u(e){let t=Array.from({length:s},()=>Array.from({length:s},()=>!1));if(!e)return t;let n=l(e);for(let e=0;e<s;e++)for(let r=0;r<c;r++){let i=(n&1)==1;n>>>=1,t[e][r]=i,t[e][4-r]=i}return t}var d=e(),f=e=>{let t=(0,i.c)(27),{name:n,emoji:a,size:s,className:c,label:l}=e,f=s===void 0?16:s,m,h,g;if(t[0]!==c||t[1]!==a||t[2]!==n){m=o(n);let e;t[6]===n?e=t[7]:(e=u(n),t[6]=n,t[7]=e),h=e,g=r(`inline-flex aspect-square shrink-0 overflow-hidden rounded-sm`,a&&`items-center justify-center select-none`,m.class,c),t[0]=c,t[1]=a,t[2]=n,t[3]=m,t[4]=h,t[5]=g}else m=t[3],h=t[4],g=t[5];let _=`calc(${f}px * var(--dpt-n, 1))`,v=`calc(${f}px * var(--dpt-n, 1))`,y=`calc(${f}px * var(--dpt-n, 1))`,b=`calc(${f}px * var(--dpt-n, 1))`,x=`calc(${f}px * var(--dpt-n, 1))`,S=`calc(${f}px * var(--dpt-n, 1))`,C=`var(${m.var})`,w;t[8]!==_||t[9]!==v||t[10]!==y||t[11]!==b||t[12]!==x||t[13]!==S||t[14]!==C?(w={width:_,minWidth:v,maxWidth:y,height:b,minHeight:x,maxHeight:S,color:C},t[8]=_,t[9]=v,t[10]=y,t[11]=b,t[12]=x,t[13]=S,t[14]=C,t[15]=w):w=t[15];let T=l?`img`:void 0,E=!l||void 0,D;t[16]!==a||t[17]!==h||t[18]!==f?(D=a?(0,d.jsx)(`span`,{"aria-hidden":`true`,style:{fontSize:`calc(${f*.75}px * var(--dpt-n, 1))`,lineHeight:1},children:a}):(0,d.jsxs)(`svg`,{width:f,height:f,viewBox:`0 0 5 5`,shapeRendering:`crispEdges`,className:`oc-agent-avatar block h-full w-full`,"aria-hidden":`true`,children:[(0,d.jsx)(`rect`,{width:`5`,height:`5`,fill:`currentColor`,opacity:.14}),h.map(p)]}),t[16]=a,t[17]=h,t[18]=f,t[19]=D):D=t[19];let O;return t[20]!==l||t[21]!==w||t[22]!==T||t[23]!==E||t[24]!==D||t[25]!==g?(O=(0,d.jsx)(`span`,{className:g,style:w,role:T,"aria-label":l,"aria-hidden":E,children:D}),t[20]=l,t[21]=w,t[22]=T,t[23]=E,t[24]=D,t[25]=g,t[26]=O):O=t[26],O};function p(e,t){return e.map((e,n)=>e?(0,d.jsx)(`rect`,{x:n,y:t,width:`1`,height:`1`,fill:`currentColor`},`${n}-${t}`):null)}export{o as n,f as t};