thursday-agent 0.5.0 → 0.6.0

package/features/workspace/workspace.query.ts

@@ -69,6 +69,23 @@ export async function readWorkspaceFolder(
   };
 }
 
+/**
+ * Which of these workspace-relative paths name no file: a message can mention a
+ * file that was never written or has since gone. A path that leaves the workspace
+ * is not judged and never listed.
+ */
+export async function findMissingFiles(paths: string[]): Promise<string[]> {
+  const missing = await Promise.all(
+    paths.map(async (path) => {
+      const full = await insideWorkspace(path);
+      if (!full) return null;
+      const info = await stat(full).catch(() => null);
+      return info?.isFile() ? null : path;
+    }),
+  );
+  return missing.filter((path) => path !== null);
+}
+
 /** Deletes one file. Folders are refused: a whole tree goes through `emptyScratch`. */
 export async function deleteWorkspaceFile(rel: string): Promise<void> {
   const full = await insideWorkspace(rel);

package/features/workspace/workspace.ts

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
 import {
   mkdir,
   readdir,
@@ -62,14 +63,27 @@ const under = (root: string, path: string) =>
 /**
  * Why a file may not be written where the model asked, as one line it can act
  * on, or null when it may. Refused: the workspace root (files belong in one
- * of the three folders) and anything inside the app running the bot.
+ * of the folders), a new entry at the top of `artifacts/` other than the
+ * bot's own folder, and anything inside the app running the bot. What already
+ * sits in `artifacts/` — another bot's folder, an older result — stays editable.
  */
-export function writeRefusal(full: string): string | null {
+export function writeRefusal(full: string, bot?: string): string | null {
   if (under(WORKSPACE, full)) {
     const rel = relative(WORKSPACE, full);
-    const [top] = rel.split(sep);
-    if (top && WRITABLE.has(top)) return null;
-    return `Not written: ${rel || "the workspace root"} is outside the workspace's folders. Finished work goes under ${PATHS.artifacts}/, code under ${PATHS.projects}/, your own kit under ${PATHS.bots}/, and this job's working material under ${PATHS.scratch}/.`;
+    const [top, entry] = rel.split(sep);
+    if (!top || !WRITABLE.has(top)) {
+      return `Not written: ${rel || "the workspace root"} is outside the workspace's folders. Finished work goes under ${bot ? botArtifacts(bot) : PATHS.artifacts}/, code under ${PATHS.projects}/, your own kit under ${PATHS.bots}/, and this job's working material under ${PATHS.scratch}/.`;
+    }
+    if (
+      bot &&
+      top === PATHS.artifacts &&
+      entry &&
+      entry.toLowerCase() !== botFolderName(bot).toLowerCase() &&
+      !existsSync(join(ARTIFACTS, entry))
+    ) {
+      return `Not written: ${rel} would sit loose at the top of ${PATHS.artifacts}/. Your finished work goes in ${botArtifacts(bot)}/.`;
+    }
+    return null;
   }
   if (under(APP_ROOT, full)) {
     return `Not written: ${full} is inside the app that is running you, not the user's files. Work in ${WORKSPACE}; outside it, write only where the user pointed you.`;
@@ -98,19 +112,17 @@ export async function insideWorkspace(rel: string): Promise<string | null> {
 }
 
 /**
- * Where one job keeps what it is still working on. `scratch/` used to be shared
- * by every job at once, so nobody could tell whose a file was or when it stopped
- * mattering, and it only grew. A job has a beginning and an end, which is what
- * makes its working material safe to clear later — and it is the right unit
- * rather than the bot, because several bots work inside one job (`ask_bot`) and
+ * Where one job keeps what it is still working on. A job has a beginning and an
+ * end, which is what makes its working material safe to clear later — and it is
+ * the right unit rather than the bot, because several bots work inside one job and
  * one bot runs many jobs.
  *
  * Named for the label so the folder is readable on the Workspace screen, with
  * the head of the id after it so two jobs called the same thing stay apart.
- * Finished work never lands here: that is `artifacts/`, which stays flat and
- * unattributed, and code is `projects/`, which outlives the job that started it.
+ * Finished work never lands here: that is the bot's own folder in `artifacts/`,
+ * and code is `projects/`, which outlives the job that started it.
  */
-export function jobScratch(taskId: string, label: string): string {
+export function jobScratch(threadId: string, label: string): string {
   const slug =
     label
       .trim()
@@ -118,25 +130,48 @@ export function jobScratch(taskId: string, label: string): string {
       .replace(/[^\p{L}\p{N}]+/gu, "-")
       .replace(/^-+|-+$/g, "")
       .slice(0, 40) || "job";
-  return `${PATHS.scratch}/${slug}-${taskId.slice(0, 6)}`;
+  return `${PATHS.scratch}/${slug}-${threadId.slice(0, 6)}`;
 }
 
+/**
+ * A bot's name as one path segment, the same under `bots/` and `artifacts/`.
+ * Two names that give the same segment would share both folders, so creating
+ * a bot refuses one (bot.query createBot); compared lowercased, as macOS does.
+ */
+export const botFolderName = (bot: string): string =>
+  bot.replace(/[^\p{L}\p{N}_-]+/gu, "-");
+
 /** Where one bot keeps what it wants on its next job (config PATHS.bots). */
 export const botFolder = (bot: string): string =>
-  `${PATHS.bots}/${bot.replace(/[^\p{L}\p{N}_-]+/gu, "-")}`;
+  `${PATHS.bots}/${botFolderName(bot)}`;
 
-export async function openBotFolder(bot: string): Promise<string> {
-  const path = botFolder(bot);
-  await mkdir(join(WORKSPACE, path), { recursive: true });
-  return path;
+/**
+ * Where one bot's finished work goes. The Artifacts section draws each as that
+ * bot's group (features/artifact), so a result is filed by who made it.
+ */
+export const botArtifacts = (bot: string): string =>
+  `${PATHS.artifacts}/${botFolderName(bot)}`;
+
+/** Both of a bot's folders, created so its first write never has to. */
+export async function openBotFolders(
+  bot: string,
+): Promise<{ own: string; artifacts: string }> {
+  const own = botFolder(bot);
+  const artifacts = botArtifacts(bot);
+  await Promise.all(
+    [own, artifacts].map((path) =>
+      mkdir(join(WORKSPACE, path), { recursive: true }),
+    ),
+  );
+  return { own, artifacts };
 }
 
 /** Creates it, so a job never has to and never writes to the shared root by mistake. */
 export async function openJobScratch(
-  taskId: string,
+  threadId: string,
   label: string,
 ): Promise<string> {
-  const path = jobScratch(taskId, label);
+  const path = jobScratch(threadId, label);
   await mkdir(join(WORKSPACE, path), { recursive: true });
   return path;
 }
@@ -147,19 +182,27 @@ export async function openJobScratch(
  * runner can close exactly this session when the job ends.
  */
 export const jobShellEnv = (
-  taskId: string | null | undefined,
+  threadId: string | null | undefined,
 ): Record<string, string> =>
-  taskId
+  threadId
     ? {
-        PLAYWRIGHT_CLI_SESSION: `task-${taskId}`,
+        PLAYWRIGHT_CLI_SESSION: `thread-${threadId}`,
         // Read by playwright-cli; the window it opens is on the user's screen
         PLAYWRIGHT_MCP_VIEWPORT_SIZE: BROWSER_VIEWPORT,
       }
     : {};
 
+/**
+ * A bot's artifacts folder in its shell, for a script that delivers a file
+ * rather than a model typing the path (skills/interactive-page bundle-artifact.sh).
+ */
+export const botShellEnv = (bot: string): Record<string, string> => ({
+  THURSDAY_ARTIFACTS: botArtifacts(bot),
+});
+
 /** A participant's browser belongs to the job and its canonical bot name, across every caller. */
-export const botBrowserSession = (taskId: string, bot: string) =>
-  `${taskId}-bot-${createHash("sha256").update(bot.toLowerCase()).digest("hex").slice(0, 20)}`;
+export const botBrowserSession = (threadId: string, bot: string) =>
+  `${threadId}-bot-${createHash("sha256").update(bot.trim().toLowerCase()).digest("hex").slice(0, 20)}`;
 
 /** Set by `ensureBrowser`, read by `readMachineTools`; null until it has finished. */
 let browserReady: boolean | null = null;
@@ -240,25 +283,28 @@ export async function pruneJobFiles(): Promise<void> {
 type ListedBrowser = { name: string; headed?: boolean; attached?: boolean };
 
 /**
- * A job that ended closes the browser nobody can see. Headless is the bot's
+ * An expired job's workspace closes browsers nobody can see. Headless is the bot's
  * working copy; `--headed` is the bot putting a window on their screen on
  * purpose — an order at checkout, a map with a pin, a sign-in — and that one is
  * theirs to close (`skills/browser`). A session attached to their own Chrome is
  * never touched. Anything unreadable — no playwright, a failed or folded `list`
  * — leaves the browser as it is.
  */
-export async function closeHiddenBrowser(taskId: string): Promise<void> {
-  await closeBrowsers(taskId, false);
+export async function closeHiddenBrowser(threadId: string): Promise<void> {
+  await closeBrowsers(threadId, false);
 }
 
 /** Cancel and delete close every participant's window, but never an attached personal browser. */
-export async function closeJobShell(taskId: string): Promise<void> {
-  await closeBrowsers(taskId, true);
+export async function closeJobShell(threadId: string): Promise<void> {
+  await closeBrowsers(threadId, true);
 }
 
-async function closeBrowsers(taskId: string, visible: boolean): Promise<void> {
+async function closeBrowsers(
+  threadId: string,
+  visible: boolean,
+): Promise<void> {
   const sandbox = await openWorkspace();
-  const env = jobShellEnv(taskId);
+  const env = jobShellEnv(threadId);
   const listed = await sandbox
     .exec("playwright-cli list --json", { env, timeoutMs: 15_000 })
     .catch(() => null);
@@ -396,15 +442,15 @@ export async function filesOnDisk(
 }
 
 /**
- * Removes a job's working folder. Its lifetime is the task's: when the row goes,
+ * Removes a job's working folder. Its lifetime is the thread's: when the row goes,
  * so does what it was working with (features/bot/bot.runner). Never touches
  * `artifacts` or `projects` — those are the user's and outlive every job.
  */
 export async function removeJobScratch(
-  taskId: string,
+  threadId: string,
   label: string,
 ): Promise<void> {
-  await rm(join(WORKSPACE, jobScratch(taskId, label)), {
+  await rm(join(WORKSPACE, jobScratch(threadId, label)), {
     recursive: true,
     force: true,
   }).catch(() => {});

package/lib/live/live.schema.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+
+export const LIVE_MODEL = "gpt-live-1";
+export const LIVE_BACKEND_MODEL = "gpt-5.6-luna";
+
+/** Provider maxima for the startup `input`: how many messages, and their combined tokens. */
+export const LIVE_INPUT = { messages: 128, tokens: 8_192 };
+
+/** Flat function declaration accepted by Responses delegation. */
+export type ToolManifest = {
+  name: string;
+  description: string;
+  parameters: ObjectSchema;
+};
+
+/** Original text and intervals survive display grouping and late delivery. */
+export const LiveFragmentSchema = z.object({
+  start: z.number().nonnegative(),
+  end: z.number().nonnegative(),
+  text: z.string(),
+});
+export type LiveFragment = z.infer<typeof LiveFragmentSchema>;
+
+/** Earlier conversation seeded at startup. Live has no system role here; a trusted note is a developer message. */
+export type LiveInput =
+  | {
+      type: "message";
+      role: "developer";
+      content: [{ type: "input_text"; text: string }];
+    }
+  | {
+      type: "message";
+      role: "user";
+      content: [{ type: "input_text"; text: string }];
+    }
+  | {
+      type: "message";
+      role: "assistant";
+      content: [{ type: "output_text"; text: string }];
+    };
+
+/** What `session.closed` confirmed: the provider's reason and the active seconds billed. */
+export const LiveCloseSchema = z.object({
+  reason: z.string().max(128),
+  seconds: z.number().nonnegative().nullable(),
+});
+export type LiveClose = z.infer<typeof LiveCloseSchema>;

package/lib/live/live.server.ts

@@ -0,0 +1,155 @@
+import { z } from "zod";
+import { LIVE_CALL } from "@/config";
+import { logger } from "@/lib/logger";
+import { publicError } from "@/lib/public-error";
+import { LIVE_MODEL, type LiveInput, type ToolManifest } from "./live.schema";
+
+const LiveConnectionSchema = z.object({
+  session: z.object({ id: z.string().min(1) }),
+  transport: z.object({ type: z.literal("webrtc"), sdp: z.string().min(1) }),
+});
+
+/** The backend's `reasoning` settings as Responses takes them. */
+export type BackendReasoning = { effort?: string; summary?: "auto" };
+
+/** What each model took, by model and chosen effort; only settled answers are kept. */
+const reasoningTaken = new Map<string, BackendReasoning | null>();
+
+/**
+ * The reasoning settings to hand the backend: the chosen effort, and a summary kept with
+ * the call (call_thought), none of either for `none`. Live opens the call with any of
+ * them and fails the first delegated response when the model refuses one, so the model
+ * is asked before the call: the token-count endpoint checks `reasoning` without running
+ * it. A setting refused by name is dropped and the rest asked again, and what was taken
+ * is remembered. Any other answer keeps what was chosen: a key or model problem is Live's
+ * to report when the call opens. A dropped setting is not shown; the call runs on the
+ * model's own.
+ */
+export async function acceptedReasoning(options: {
+  apiKey: string;
+  model: string;
+  effort: string | null;
+}): Promise<BackendReasoning | null> {
+  const { apiKey, model, effort } = options;
+  const pair = `${model} ${effort ?? "auto"}`;
+  const known = reasoningTaken.get(pair);
+  if (known !== undefined) return known;
+
+  const wanted: BackendReasoning =
+    effort === "none"
+      ? { effort }
+      : { ...(effort ? { effort } : {}), summary: "auto" };
+  for (;;) {
+    const response = await fetch(
+      "https://api.openai.com/v1/responses/input_tokens",
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json",
+        },
+        signal: AbortSignal.timeout(LIVE_CALL.reasoningCheckMs),
+        body: JSON.stringify({ model, input: ".", reasoning: wanted }),
+      },
+    ).catch(() => null);
+    if (!response) return wanted;
+    const taken = Object.keys(wanted).length ? wanted : null;
+    if (response.ok) {
+      reasoningTaken.set(pair, taken);
+      return taken;
+    }
+    const payload = (await response.json().catch(() => null)) as {
+      error?: { param?: string | null };
+    } | null;
+    const refused = payload?.error?.param?.replace(/^reasoning\./, "");
+    if (refused !== "effort" && refused !== "summary") return wanted;
+    if (!(refused in wanted)) return wanted;
+    logger.warn(`${model} takes no reasoning ${refused}; calls omit it`);
+    delete wanted[refused];
+    if (!Object.keys(wanted).length) {
+      reasoningTaken.set(pair, null);
+      return null;
+    }
+  }
+}
+
+/** Exchanges an offer on the trusted server. The account key never reaches the browser. */
+export async function createLiveCall(options: {
+  apiKey: string;
+  sdp: string;
+  voice: string;
+  instructions: string;
+  input: LiveInput[];
+  backend: {
+    model: string;
+    instructions: string;
+    tools: ToolManifest[];
+    /** What `acceptedReasoning` found the model takes; omitted when null. */
+    reasoning: BackendReasoning | null;
+    webSearch: boolean;
+  };
+}) {
+  const response = await fetch("https://api.openai.com/v1/live/sessions", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${options.apiKey}`,
+      "Content-Type": "application/json",
+    },
+    signal: AbortSignal.timeout(LIVE_CALL.startupMs),
+    body: JSON.stringify({
+      session: {
+        model: LIVE_MODEL,
+        instructions: options.instructions,
+        input: options.input,
+        audio: { output: { voice: options.voice } },
+        store: false,
+        delegation: {
+          type: "responses",
+          responses: {
+            model: options.backend.model,
+            instructions: options.backend.instructions,
+            // `strict` is left out, not false: each tool whose schema allows it is
+            // decoded to its schema, and the rest fall back to best effort. `true`
+            // is refused while any schema has optional fields.
+            tools: [
+              ...options.backend.tools.map((tool) => ({
+                type: "function",
+                ...tool,
+              })),
+              ...(options.backend.webSearch ? [{ type: "web_search" }] : []),
+            ],
+            tool_choice: "auto",
+            parallel_tool_calls: true,
+            max_output_tokens: LIVE_CALL.backendOutputTokens,
+            ...(options.backend.reasoning
+              ? { reasoning: options.backend.reasoning }
+              : {}),
+          },
+        },
+      },
+      transport: { type: "webrtc", sdp: options.sdp },
+    }),
+  }).catch((cause: unknown) => {
+    logger.warn("OpenAI Live unreachable", cause);
+    publicError("Could not reach OpenAI Live.");
+  });
+  const body = await response.text();
+  let payload: unknown;
+  try {
+    payload = JSON.parse(body);
+  } catch {
+    payload = null;
+  }
+  if (!response.ok) {
+    const error = payload as { error?: { message?: string } } | null;
+    publicError(
+      error?.error?.message ||
+        body ||
+        `OpenAI Live refused the call (${response.status}).`,
+    );
+  }
+  const parsed = LiveConnectionSchema.safeParse(payload);
+  if (!parsed.success)
+    publicError("OpenAI Live returned an invalid session connection.");
+  return parsed.data;
+}