mirror of
https://github.com/stablyai/orca.git
synced 2026-11-05 03:27:44 +00:00
Brennan Benson
563dd5487f
* feat(native-chat): show a Codex chat's goal above the composer and set it from goal mode Structured Codex chat now treats the thread goal as session state: a banner above the composer shows the current goal (pursuing / paused) with clear, pause/resume and expand; /goal enters a goal mode whose send calls thread/goal/set; the objective is journaled as a user message marked as sent as a goal. The banner is derived from the journaled goal rows, which Codex's resume snapshot refreshes, so a reopened or adopted chat shows its goal. Fixes STA-8159 * fix(native-chat): replace a recorded goal by clearing first, and recover a lost goal-change response - A set while the journal records a goal (any status) clears it before setting, so the new goal starts with its own time and token counters instead of rewriting the old goal's objective in place. - The threadGoal plan answers an unknown outcome from the goal the journal records and reruns otherwise, so one request timeout no longer refuses every later Clear/Pause/Resume as unknown for the mounted session. - The goal-mode chip says "Exit goal mode"; "Clear goal" stays the banner's action on the provider goal. - A typed bare /goal on Enter enters goal mode, the same as picking it. - The renderer reads the goal off the tail of its ordered snapshot; the host's unordered map keeps the by-sequence reader. - Drop the composer's duplicate in-flight guard; the goal controller already serializes changes. - Pin that a counter-only revision reaches a subscriber's live page under its original sequence. * fix(native-chat): keep a bare /goal inside goal mode as the entrance, and pin goal delivery and serialization - A bare `/goal` submitted while already in goal mode re-enters the mode instead of setting a goal whose objective is the literal text "/goal". - The counter-only revision pin now drives the host's own event sink bound to a real journal, so it goes red when the publish after a lifecycle transition is dropped; the previous fake sink never published. - Pin that a set which threw after journaling its objective puts that objective back exactly once when the ledger reruns the same operation id. - Cover the goal controller hook: absent without host support, the loaded window wins over the host's answer, a second change while one is unsettled answers false without a request, and a refused change frees the next one. * fix(native-chat): resume a blocked or usage-limited goal, and keep goal-mode drafts honest - The goal bar offers Resume on a blocked or usage-limited goal, which the provider resumes exactly as it resumes a paused one; a goal whose token budget is spent still offers only Clear. The rule lives beside the other goal facts in shared code so every reader answers it the same way. - A `/goal <text>` typed inside goal mode sets the objective `<text>`, as it does outside goal mode, instead of a goal whose objective is the literal command. - Setting a goal is a host round trip; a draft edited while it was in flight is no longer wiped when the goal lands, matching every other host command. - Pin that a lost status-change response is read as applied only when the recorded goal is in that status, that a cleared row in the loaded window outranks the host's earlier answer, and that the PTY lane is untouched. * fix(native-chat): keep the load-older anchor on the loaded window when a live revision lands below it A live revision of a row keeps that row's original sequence. When the row is older than the client's loaded window, the shared reducer merged it in and it became the load-older anchor, so paging `before` it skipped every row between. A goal's counter-only revisions during a long goal turn reach any client that attached after the goal row left its window, so a reopened chat lost rows on scroll-back. The reducer now admits live rows only at or above the window's oldest row while older rows remain on the host; the journal keeps the revision and the page reader serves it once the window reaches the row. With nothing older on the host the window is the whole journal, so a row below the head is admitted as before. Also drain accepted provider events before a goal set reads the journal to decide whether it replaces a recorded goal.
95 lines
3.8 KiB
TypeScript
95 lines
3.8 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest'
|
|
import { CodexAppServerRequestError } from './codex-app-server-request-error'
|
|
import { changeCodexThreadGoal, codexThreadGoalRequests } from './codex-structured-thread-goal'
|
|
import type { CodexSession } from './codex-structured-session-state'
|
|
|
|
const THREAD = 'thread-1'
|
|
|
|
function session(request: (...args: unknown[]) => Promise<unknown>) {
|
|
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the goal path reads only these two fields.
|
|
return { threadId: THREAD, connection: { request } } as unknown as Pick<
|
|
CodexSession,
|
|
'connection' | 'threadId'
|
|
>
|
|
}
|
|
|
|
describe('codex thread goal requests', () => {
|
|
it('sets an objective as an active goal with no turn of its own', () => {
|
|
expect(codexThreadGoalRequests(THREAD, { kind: 'set', objective: 'Ship it' }, false)).toEqual([
|
|
{
|
|
method: 'thread/goal/set',
|
|
params: { threadId: THREAD, objective: 'Ship it', status: 'active' }
|
|
}
|
|
])
|
|
})
|
|
|
|
it('clears the existing goal before setting a new objective, so the new goal starts fresh', () => {
|
|
expect(codexThreadGoalRequests(THREAD, { kind: 'set', objective: 'Ship it' }, true)).toEqual([
|
|
{ method: 'thread/goal/clear', params: { threadId: THREAD } },
|
|
{
|
|
method: 'thread/goal/set',
|
|
params: { threadId: THREAD, objective: 'Ship it', status: 'active' }
|
|
}
|
|
])
|
|
})
|
|
|
|
it('pauses and resumes by status alone, keeping the objective', () => {
|
|
expect(codexThreadGoalRequests(THREAD, { kind: 'status', status: 'paused' }, true)).toEqual([
|
|
{ method: 'thread/goal/set', params: { threadId: THREAD, status: 'paused' } }
|
|
])
|
|
expect(codexThreadGoalRequests(THREAD, { kind: 'status', status: 'active' }, true)).toEqual([
|
|
{ method: 'thread/goal/set', params: { threadId: THREAD, status: 'active' } }
|
|
])
|
|
})
|
|
|
|
it('clears with only the thread id', () => {
|
|
expect(codexThreadGoalRequests(THREAD, { kind: 'clear' }, true)).toEqual([
|
|
{ method: 'thread/goal/clear', params: { threadId: THREAD } }
|
|
])
|
|
})
|
|
|
|
it('sends each request in order with the session deadline', async () => {
|
|
const request = vi.fn(async () => ({ goal: null }))
|
|
await expect(
|
|
changeCodexThreadGoal(session(request), { kind: 'set', objective: 'Ship it' }, true, 5_000)
|
|
).resolves.toEqual({ ok: true })
|
|
expect(request.mock.calls).toEqual([
|
|
['thread/goal/clear', { threadId: THREAD }, { timeoutMs: 5_000 }],
|
|
[
|
|
'thread/goal/set',
|
|
{ threadId: THREAD, objective: 'Ship it', status: 'active' },
|
|
{ timeoutMs: 5_000 }
|
|
]
|
|
])
|
|
})
|
|
|
|
it('stops at a refused clear, so a refused replacement leaves the old goal alone', async () => {
|
|
const request = vi.fn(async (method: unknown) => {
|
|
if (method === 'thread/goal/clear') {
|
|
throw new CodexAppServerRequestError('thread/goal/clear', -32600, 'goals are disabled')
|
|
}
|
|
return { goal: null }
|
|
})
|
|
await expect(
|
|
changeCodexThreadGoal(session(request), { kind: 'set', objective: 'Ship it' }, true, 5_000)
|
|
).resolves.toEqual({ ok: false, rejected: 'goals are disabled' })
|
|
expect(request).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it('reports a provider refusal and rethrows anything that leaves the effect unknown', async () => {
|
|
const refused = session(async () => {
|
|
throw new CodexAppServerRequestError('thread/goal/set', -32600, 'goals feature is disabled')
|
|
})
|
|
await expect(
|
|
changeCodexThreadGoal(refused, { kind: 'set', objective: 'Ship it' }, false, undefined)
|
|
).resolves.toEqual({ ok: false, rejected: 'goals feature is disabled' })
|
|
|
|
const lost = session(async () => {
|
|
throw new Error('codex app-server request timed out')
|
|
})
|
|
await expect(changeCodexThreadGoal(lost, { kind: 'clear' }, false, undefined)).rejects.toThrow(
|
|
'timed out'
|
|
)
|
|
})
|
|
})
|