@questionbase/deskfree 0.3.0-alpha.26 → 0.3.0-alpha.28

package/dist/index.js

@@ -4655,6 +4655,17 @@ async function deliverMessageToAgent(ctx, message, client) {
       replyOptions
     });
     log.info(`Message ${message.messageId} dispatched successfully.`);
+    const activeSession = streamingSession;
+    if (activeSession?.isActive()) {
+      try {
+        await activeSession.close(accumulatedText || void 0);
+        log.info("Streaming reply finalized (post-dispatch cleanup).");
+      } catch (closeErr) {
+        const msg = closeErr instanceof Error ? closeErr.message : String(closeErr);
+        log.warn(`Post-dispatch streaming close failed: ${msg}`);
+      }
+      streamingSession = null;
+    }
   } catch (err) {
     const session = streamingSession;
     if (session?.isActive()) {
@@ -4697,6 +4708,12 @@ var wrapper_default = import_websocket.default;
 var activeTaskId = null;
 var completedTaskId = null;
 var inboundThreadId = null;
+function setActiveTaskId(taskId) {
+  if (taskId === null && activeTaskId !== null) {
+    completedTaskId = activeTaskId;
+  }
+  activeTaskId = taskId;
+}
 function getActiveTaskId() {
   return activeTaskId ?? completedTaskId ?? inboundThreadId;
 }
@@ -8788,11 +8805,12 @@ You are the orchestrator. Your job: turn human intent into approved tasks, then
 3. **Dispatch** \u2192 spawn a sub-agent for each approved task. Pass the taskId.
 4. **Communicate** \u2192 \`deskfree_send_message\` for updates outside task threads.
 
-**Bias toward action, not questions.** When a human gives you a direction:
-- Don't ask clarifying questions in the main thread. Propose tasks instead.
-- If the request is clear ("audit my LinkedIn profile"), propose the task directly \u2014 no scoping needed.
-- If the request is ambiguous ("I want to be a LinkedIn influencer"), propose a scoping task first: "Research current state and draft a plan" \u2014 the worker reports back with findings and follow-up proposals.
-- Discovery happens inside tasks, not in conversation. Tasks produce deliverables; questions don't.
+**Always explain before proposing.** When a human gives you a direction:
+- First, respond in chat with your understanding and plan \u2014 what you'll do, how you'll break it down, what the deliverables will be.
+- Then call \`deskfree_propose\` with the concrete tasks. The human sees your thinking first, then the actionable proposal.
+- If the request is clear ("audit my LinkedIn profile"), a brief "Here's what I'll do:" is enough before proposing.
+- If the request is ambiguous ("I want to be a LinkedIn influencer"), explain your approach, then propose a scoping task.
+- Never call \`deskfree_propose\` as your first action \u2014 always write a message first.
 
 You do NOT claim tasks or do work directly. Sub-agents handle execution.
 - When a human writes in a task thread, you receive it with recent context. Use \`deskfree_reopen_task\` if it needs more work.
@@ -8842,6 +8860,54 @@ function resolveAccountFromConfig(api) {
     enabled: ch.enabled !== false
   };
 }
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+var MAX_TASK_CONTEXT_TOKENS = 8e3;
+var MAX_FULL_MESSAGES = 15;
+var MAX_FILE_CONTENT_CHARS = 4e3;
+function trimTaskContext(result) {
+  const raw = result;
+  const trimmed = {
+    taskId: result.taskId,
+    title: result.title,
+    status: result.status,
+    instructions: result.instructions
+  };
+  if (raw["substeps"]) {
+    trimmed.substeps = raw["substeps"];
+  }
+  if (raw["parentContext"]) {
+    trimmed.parentContext = raw["parentContext"];
+  }
+  if (result.messages && result.messages.length > 0) {
+    if (result.messages.length <= MAX_FULL_MESSAGES) {
+      trimmed.messages = result.messages;
+    } else {
+      const omitted = result.messages.length - MAX_FULL_MESSAGES;
+      const recentMessages = result.messages.slice(-MAX_FULL_MESSAGES);
+      trimmed.messages = recentMessages;
+      trimmed.messagesOmitted = `${omitted} earlier message(s) omitted \u2014 use deskfree_send_message to ask about history if needed`;
+    }
+  }
+  if (result.fileContext) {
+    const fc = result.fileContext;
+    if (fc.content.length > MAX_FILE_CONTENT_CHARS) {
+      trimmed.fileContext = {
+        fileId: fc.fileId,
+        name: fc.name,
+        description: fc.description,
+        contentFormat: fc.contentFormat,
+        version: fc.version,
+        content: fc.content.slice(0, MAX_FILE_CONTENT_CHARS),
+        contentTruncated: `Content truncated from ${fc.content.length} chars. Full content available \u2014 use deskfree_update_file with the complete replacement when editing.`
+      };
+    } else {
+      trimmed.fileContext = fc;
+    }
+  }
+  return trimmed;
+}
 function formatTaskResponse(task, summary, nextActions) {
   return {
     content: [
@@ -8947,6 +9013,33 @@ function validateStringParam(params, key, required) {
   }
   return value;
 }
+function validateEnumParam(params, key, allowedValues, required) {
+  if (!params) {
+    if (required) {
+      throw new Error(
+        `Required parameter '${key}' is missing (no params provided)`
+      );
+    }
+    return void 0;
+  }
+  const value = params[key];
+  if (value == null) {
+    if (required) throw new Error(`Required parameter '${key}' is missing`);
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Parameter '${key}' must be a string, got ${typeof value}`);
+  }
+  if (required && value.trim() === "") {
+    throw new Error(`Required parameter '${key}' cannot be empty`);
+  }
+  if (!allowedValues.includes(value)) {
+    throw new Error(
+      `Parameter '${key}' must be one of: ${allowedValues.join(", ")}, got: ${value}`
+    );
+  }
+  return value;
+}
 function parseProposeTasks(raw) {
   if (!Array.isArray(raw) || raw.length === 0) {
     throw new Error('Parameter "tasks" must be a non-empty array');
@@ -9002,6 +9095,65 @@ function parseInitiative(raw) {
   }
   return void 0;
 }
+function makeUpdateFileHandler(client) {
+  return async (_id, params) => {
+    try {
+      const fileId = validateStringParam(params, "fileId", true);
+      const content = validateStringParam(params, "content", true);
+      const contentFormat = validateEnumParam(
+        params,
+        "contentFormat",
+        ["markdown", "html"],
+        false
+      );
+      await client.updateFile({ fileId, content, contentFormat });
+      return formatConfirmation(`Updated file ${fileId}`, [
+        "File content has been saved",
+        "Complete the task with deskfree_complete_task when ready"
+      ]);
+    } catch (err) {
+      return errorResult(err);
+    }
+  };
+}
+function makeCompleteTaskHandler(client) {
+  return async (_id, params) => {
+    try {
+      const taskId = validateStringParam(params, "taskId", true);
+      const outcome = validateEnumParam(
+        params,
+        "outcome",
+        ["done", "blocked"],
+        true
+      );
+      const summary = validateStringParam(params, "summary", false);
+      const evaluation = params?.evaluation;
+      const result = await client.completeTask({
+        taskId,
+        outcome,
+        summary,
+        ...evaluation ? { evaluation } : {}
+      });
+      setActiveTaskId(null);
+      const summaryVerb = outcome === "done" ? "completed" : "blocked";
+      const icon = outcome === "done" ? "\u2705" : "\u{1F6AB}";
+      await client.sendMessage({
+        content: `${icon} Task ${summaryVerb}: "${result.title}"`
+      }).catch(() => {
+      });
+      return formatTaskResponse(
+        result,
+        `Task "${result.title}" marked as ${summaryVerb} \u2014 waiting for human`,
+        [
+          outcome === "done" ? "Human will review your work summary" : "Human will review the blocker and provide guidance",
+          "Use deskfree_state to check for other tasks"
+        ]
+      );
+    } catch (err) {
+      return errorResult(err);
+    }
+  };
+}
 function makeReopenTaskHandler(client) {
   return async (_id, params) => {
     try {
@@ -9133,6 +9285,84 @@ function createOrchestratorTools(api) {
     }
   ];
 }
+function createWorkerTools(api) {
+  const account = resolveAccountFromConfig(api);
+  if (!account) return null;
+  const client = new DeskFreeClient(account.botToken, account.apiUrl);
+  return [
+    {
+      ...WORKER_TOOLS.START_TASK,
+      async execute(_id, params) {
+        try {
+          const taskId = validateStringParam(params, "taskId", true);
+          const runnerId = validateStringParam(params, "runnerId", false);
+          const result = await client.claimTask({ taskId, runnerId });
+          setActiveTaskId(taskId);
+          let skillInstructions = "";
+          if (result.skillContext?.length) {
+            skillInstructions = result.skillContext.map(
+              (s) => `
+\u26A0\uFE0F SKILL: ${s.displayName}
+${s.criticalSection}
+
+${s.instructions}`
+            ).join("\n\n---\n");
+          }
+          const trimmedTask = trimTaskContext(result);
+          const taskJson = JSON.stringify(
+            {
+              summary: `Claimed task "${result.title}" \u2014 full context loaded${result.skillContext?.length ? ` (${result.skillContext.length} skill${result.skillContext.length > 1 ? "s" : ""} active)` : ""}`,
+              mode: trimmedTask.mode ?? "work",
+              nextActions: [
+                "Read the instructions and message history carefully",
+                ...result.fileContext ? [
+                  `Task has a linked file "${result.fileContext.name}" (ID: ${result.fileContext.fileId}) \u2014 use deskfree_update_file to save your work to it`
+                ] : [],
+                ...trimmedTask.mode === "evaluation" ? [
+                  "This is an evaluation task \u2014 review the WoW context and provide your evaluation in deskfree_complete_task"
+                ] : [],
+                "Complete with deskfree_complete_task when done (summary required)"
+              ],
+              task: trimmedTask
+            },
+            null,
+            2
+          );
+          const totalTokens = estimateTokens(skillInstructions) + estimateTokens(taskJson);
+          const budgetWarning = totalTokens > MAX_TASK_CONTEXT_TOKENS ? `
+\u26A0\uFE0F Context budget: ~${totalTokens} tokens loaded (~${MAX_TASK_CONTEXT_TOKENS} target). Be concise in your reasoning.` : "";
+          return {
+            content: [
+              ...skillInstructions ? [{ type: "text", text: skillInstructions }] : [],
+              {
+                type: "text",
+                text: taskJson + budgetWarning
+              }
+            ]
+          };
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    },
+    {
+      ...WORKER_TOOLS.UPDATE_FILE,
+      execute: makeUpdateFileHandler(client)
+    },
+    {
+      ...WORKER_TOOLS.COMPLETE_TASK,
+      execute: makeCompleteTaskHandler(client)
+    },
+    {
+      ...WORKER_TOOLS.SEND_MESSAGE,
+      execute: makeSendMessageHandler(client)
+    },
+    {
+      ...WORKER_TOOLS.PROPOSE,
+      execute: makeProposeHandler(client)
+    }
+  ];
+}
 
 // src/offline-queue.ts
 var MAX_QUEUE_SIZE2 = 100;
@@ -9248,7 +9478,17 @@ var plugin = {
     setDeskFreeRuntime(api.runtime);
     api.registerChannel({ plugin: deskFreePlugin });
     api.registerTool(() => {
-      return createOrchestratorTools(api);
+      const orchestratorTools = createOrchestratorTools(api) ?? [];
+      const workerTools = createWorkerTools(api) ?? [];
+      const seen = /* @__PURE__ */ new Set();
+      const allTools = [];
+      for (const tool of [...orchestratorTools, ...workerTools]) {
+        if (!seen.has(tool.name)) {
+          seen.add(tool.name);
+          allTools.push(tool);
+        }
+      }
+      return allTools.length > 0 ? allTools : null;
     });
     api.on("before_agent_start", (_event, ctx) => {
       return { prependContext: getDeskFreeContext(ctx.sessionKey) };