fix(agent-gateway): report run_in_background on the task wire

Author: elkaix

.changeset/tasks-run-in-background.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": patch
+---
+
+Fix foreground subagents being reported as background tasks on the task list.

packages/agent-gateway/src/protocol/task.ts

@@ -30,6 +30,6 @@ export const taskSchema = z.object({
   agent_id: z.string().optional(),
   subagent_type: z.string().optional(),
   parent_tool_call_id: z.string().optional(),
-  run_in_background: z.boolean().optional(),
+  run_in_background: z.boolean(),
 });
 export type Task = z.infer<typeof taskSchema>;

packages/agent-gateway/src/routes/tasks.ts

@@ -272,7 +272,7 @@ function toWireTask(
     status,
     created_at: createdIso,
     started_at: createdIso,
-    run_in_background: info.detached !== false,
+    run_in_background: info.detached ?? true,
   };
   if (info.endedAt !== null && info.endedAt !== undefined) {
     base.completed_at = new Date(info.endedAt).toISOString();

packages/agent-gateway/test/tasks.test.ts

@@ -235,21 +235,21 @@ describe('server-v2 /api/v1/sessions/{sid}/tasks', () => {
     expect(byId.get(questionId)?.parent_tool_call_id).toBeUndefined();
   });
 
-  it('reports run_in_background false for a foreground (non-detached) task', async () => {
+  it('reports run_in_background from the task detached flag', async () => {
     const id = await createSession();
     const tasks = await mainAgentTasks(id);
+    const backgroundId = tasks.registerTask(fakeTask('agent'));
     const foregroundId = tasks.registerTask(fakeTask('agent'), { detached: false });
     await flush();
 
-    const listed = await getJson<ListWire>(`/api/v1/sessions/${id}/tasks`);
-    expect(listed.body.code).toBe(0);
-    const entry = listed.body.data.items.find((t) => t.id === foregroundId);
-    expect(entry).toMatchObject({ kind: 'subagent', status: 'running' });
-    expect(entry?.run_in_background).toBe(false);
+    const { body } = await getJson<ListWire>(`/api/v1/sessions/${id}/tasks`);
+    expect(body.code).toBe(0);
+    const byId = new Map(body.data.items.map((t) => [t.id, t]));
+    expect(byId.get(backgroundId)?.run_in_background).toBe(true);
+    expect(byId.get(foregroundId)?.run_in_background).toBe(false);
 
-    const got = await getJson<TaskWire>(`/api/v1/sessions/${id}/tasks/${foregroundId}`);
-    expect(got.body.code).toBe(0);
-    expect(got.body.data.run_in_background).toBe(false);
+    const single = await getJson<TaskWire>(`/api/v1/sessions/${id}/tasks/${foregroundId}`);
+    expect(single.body.data.run_in_background).toBe(false);
   });
 
   it('filters the list by wire status', async () => {

packages/protocol/src/__tests__/rest-task.test.ts

@@ -49,6 +49,7 @@ describe('getTaskResponseSchema', () => {
       description: 'spin up x',
       status: 'running' as const,
       created_at: '2026-06-04T10:00:00.000Z',
+      run_in_background: true,
     };
     expect(getTaskResponseSchema.parse(t).kind).toBe('subagent');
   });

packages/protocol/src/__tests__/task.test.ts

@@ -43,12 +43,19 @@ describe('taskSchema', () => {
     status: 'running',
     created_at: '2026-06-04T10:00:00.000Z',
     started_at: '2026-06-04T10:00:00.000Z',
+    run_in_background: true,
   };
 
   it('round-trips a running task', () => {
     expect(taskSchema.parse(full)).toEqual(full);
   });
 
+  it('accepts run_in_background when present and omits it freely (optional)', () => {
+    const { run_in_background: _omitted, ...withoutFlag } = full;
+    expect(taskSchema.safeParse(withoutFlag).success).toBe(true);
+    expect(taskSchema.safeParse({ ...full, run_in_background: false }).success).toBe(true);
+  });
+
   it('round-trips a completed task with completed_at + output fields', () => {
     const completed: Task = {
       ...full,

packages/protocol/src/task.ts

@@ -31,6 +31,10 @@ export const taskSchema = z.object({
   /** Subagent tasks only: the child's effective thinking effort at spawn. */
   thinking_effort: z.string().optional(),
   agent_id: z.string().optional(),
+  /** Whether the task runs detached from the caller's turn (background).
+   *  Optional: producers that predate the field (e.g. the agent-core v1
+   *  task service) omit it — consumers apply the foreground fallback. */
+  run_in_background: z.boolean().optional(),
 });
 export type Task = z.infer<typeof taskSchema>;