@opengeni/worker-bundle 0.29.0-canary.0 → 0.29.0-canary.2

package/dist/workflows/knowledge-indexing.d.ts

@@ -0,0 +1,2 @@
+/** Rebuild derived search projections; this is not a source-ingestion task. */
+export declare function knowledgeIndexingWorkflow(): Promise<void>;

package/dist/workflows.d.ts

@@ -1,3 +1,4 @@
+export { knowledgeIndexingWorkflow } from "./workflows/knowledge-indexing.js";
 export { documentIndexWorkflow, type DocumentIndexWorkflowInput } from "./workflows/document-index.js";
 export { approvalDecision, codexCapacityChanged, sessionControl, sessionAttemptQuiesced, queueChanged, sessionWorkflow, userMessage, type SessionWorkflowInput, } from "./workflows/session.js";
 export { scheduledTaskFireWorkflow, type ScheduledTaskFireWorkflowInput, } from "./workflows/scheduled-tasks.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/worker-bundle",
-  "version": "0.29.0-canary.0",
+  "version": "0.29.0-canary.2",
   "description": "OpenGeni worker entry and reusable embedded lifecycle, shipped with a release-coherent pre-bundled Temporal workflow artifact.",
   "license": "Apache-2.0",
   "repository": {
@@ -54,23 +54,24 @@
   },
   "dependencies": {
     "@llamaindex/liteparse": "2.14.2",
-    "@opengeni/agent-proto": "^0.6.0-canary.0",
-    "@opengeni/capabilities": "^0.3.3-canary.12",
-    "@opengeni/codemode": "^0.5.7-canary.0",
-    "@opengeni/codex": "^0.2.22-canary.12",
-    "@opengeni/config": "^1.2.0-canary.0",
-    "@opengeni/contracts": "^3.1.0-canary.0",
-    "@opengeni/core": "^2.10.0-canary.0",
-    "@opengeni/db": "^4.4.0-canary.0",
-    "@opengeni/documents": "^0.8.28-canary.0",
-    "@opengeni/events": "^0.4.26-canary.0",
-    "@opengeni/github": "^0.7.11-canary.0",
-    "@opengeni/network": "^0.3.1-canary.12",
-    "@opengeni/observability": "^0.8.27-canary.0",
-    "@opengeni/runtime": "^2.6.0-canary.0",
-    "@opengeni/storage": "^0.2.128-canary.0",
-    "@opengeni/tool-gateway": "^0.1.8-canary.0",
-    "@opengeni/xai-subscription": "^0.1.4-canary.12",
+    "@opengeni/agent-proto": "^0.6.0-canary.2",
+    "@opengeni/capabilities": "^0.3.3-canary.14",
+    "@opengeni/codemode": "^0.5.7-canary.2",
+    "@opengeni/codex": "^0.2.22-canary.14",
+    "@opengeni/config": "^1.2.0-canary.2",
+    "@opengeni/contracts": "^3.1.0-canary.2",
+    "@opengeni/core": "^2.10.0-canary.2",
+    "@opengeni/db": "^4.4.0-canary.2",
+    "@opengeni/documents": "^0.8.28-canary.2",
+    "@opengeni/events": "^0.4.26-canary.2",
+    "@opengeni/github": "^0.7.11-canary.2",
+    "@opengeni/network": "^0.3.1-canary.14",
+    "@opengeni/observability": "^0.8.27-canary.2",
+    "@opengeni/runtime": "^2.6.0-canary.2",
+    "@opengeni/sdk": "^5.1.0-canary.2",
+    "@opengeni/storage": "^0.2.128-canary.2",
+    "@opengeni/tool-gateway": "^0.1.8-canary.2",
+    "@opengeni/xai-subscription": "^0.1.4-canary.14",
     "@temporalio/activity": "^1.17.0",
     "@temporalio/client": "^1.17.0",
     "@temporalio/worker": "^1.17.0",

package/src/activities/agent-turn/knowledge-source-tools.ts

@@ -0,0 +1,98 @@
+import type { AttemptToolDefinition } from "@opengeni/codemode";
+import {
+  freezeAgentLearningPolicy,
+  getScheduledTaskRunAcceptedExecution,
+  readScheduledKnowledgeSource,
+  type Database,
+  type KnowledgeContext,
+} from "@opengeni/db";
+import type { RunKnowledgeSourceSyncBatchInput, RunKnowledgeSourceSyncBatchResult } from "../types";
+
+/** This tool exists only in an ordinary run with a frozen connector selection. */
+export async function createKnowledgeSourceAttemptTools(input: {
+  db: Database;
+  context: KnowledgeContext;
+  fetch: (input: RunKnowledgeSourceSyncBatchInput) => Promise<RunKnowledgeSourceSyncBatchResult>;
+}): Promise<AttemptToolDefinition[]> {
+  if (input.context.actor.kind !== "agent") return [];
+  const policy = await freezeAgentLearningPolicy(input.db, input.context);
+  if (typeof policy.scheduledTaskRunId !== "string") return [];
+  const runId = policy.scheduledTaskRunId;
+  const accepted = await getScheduledTaskRunAcceptedExecution(input.db, {
+    workspaceId: input.context.workspaceId,
+    runId,
+  });
+  const source = accepted?.task.agentConfig.knowledgeSource;
+  if (!accepted || !source || accepted.task.action.kind !== "agent_turn") return [];
+  const actor = input.context.actor;
+  const authorize = async () => {
+    const current = await freezeAgentLearningPolicy(input.db, input.context);
+    if (current.scheduledTaskRunId !== runId) throw new Error("Source run authority changed");
+  };
+  const definition = (
+    name: string,
+    title: string,
+    description: string,
+    inputSchema: AttemptToolDefinition["inputSchema"],
+    execute: (args: Record<string, unknown>) => Promise<unknown>,
+    readOnly: boolean,
+  ): AttemptToolDefinition => ({
+    identity: { serverId: "opengeni", toolName: name },
+    modelName: name,
+    codemodePath: ["opengeni", name],
+    title,
+    description,
+    inputSchema,
+    annotations: {
+      title,
+      readOnlyHint: readOnly,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: !readOnly,
+    },
+    source: "opengeni",
+    approval: "none",
+    execute: async (args) => {
+      await authorize();
+      const output = await execute(args);
+      return { isError: false, content: [{ type: "text", text: JSON.stringify(output) }] };
+    },
+  });
+  return [
+    definition(
+      "knowledge_source_fetch",
+      "Fetch selected source",
+      "Fetch a checkpointed batch from this scheduled task's selected source. Retains original files and searchable source content under the run's Knowledge policy. It does not create findings. Use knowledge_source_read to inspect content, then knowledge_save for useful findings with evidence. Call again if action is continue. Review first stages content without interrupting this task; Off keeps Knowledge disabled.",
+      { type: "object", properties: {}, additionalProperties: false },
+      async () =>
+        (await freezeAgentLearningPolicy(input.db, input.context)).effective.knowledge === "off"
+          ? { action: "disabled", reason: "Knowledge is Off for this run" }
+          : input.fetch({
+              accountId: input.context.accountId,
+              workspaceId: input.context.workspaceId,
+              taskId: accepted.task.id,
+              scheduledTaskRunId: runId,
+              sourceId: source.sourceId,
+              overlapPolicy: accepted.task.overlapPolicy === "skip" ? "skip" : "buffer_one",
+              agent: actor,
+            }),
+      false,
+    ),
+    definition(
+      "knowledge_source_read",
+      "Read selected source content",
+      "List source entries retained or updated in this run. Pass entryId to read up to 16,000 characters, following nextOffset for more. Follow nextCursor with afterId for subsequent list pages. Includes this run's pending source content so you can prepare findings in the same review batch; pending knowledge stays out of ordinary search. Use entryId and revisionId as evidence when saving findings.",
+      {
+        type: "object",
+        properties: {
+          entryId: { type: "string", format: "uuid" },
+          afterId: { type: "string", format: "uuid" },
+          offset: { type: "integer", minimum: 0, maximum: 100000000 },
+        },
+        additionalProperties: false,
+      },
+      async (args) => readScheduledKnowledgeSource(input.db, input.context, args),
+      true,
+    ),
+  ];
+}

package/src/activities/agent-turn/knowledge-sources.ts

@@ -0,0 +1,86 @@
+import { prepareKnowledgeFile } from "@opengeni/sdk/knowledge";
+import {
+  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
+  type FirstPartyMcpToolName,
+  type Permission,
+  type ResourceRef,
+  type KnowledgeFilePreparationResult,
+} from "@opengeni/contracts";
+import { allowedFirstPartyMcpToolsForSession, type Settings } from "@opengeni/config";
+import { createFirstPartyAttemptClient } from "@opengeni/runtime";
+
+export type KnowledgeSourcePreparationOutcome =
+  | KnowledgeFilePreparationResult
+  | {
+      status: "failed";
+      fileId: string;
+      message: string;
+    };
+
+/** Accepted chat/schedule resources use ordinary agent authority and policy. */
+export async function prepareTurnKnowledgeSources(input: {
+  settings: Settings;
+  scope: Parameters<typeof createFirstPartyAttemptClient>[0]["scope"];
+  resources: readonly ResourceRef[];
+  selectedTools?: readonly FirstPartyMcpToolName[] | undefined;
+  permissions?: readonly Permission[] | null | undefined;
+  learningMode: "automatic" | "review_first" | "off";
+  signal?: AbortSignal | undefined;
+  onOutcome: (outcome: KnowledgeSourcePreparationOutcome) => Promise<void>;
+  prepare?: (fileId: string) => Promise<KnowledgeFilePreparationResult>;
+}): Promise<string | undefined> {
+  const selected = allowedFirstPartyMcpToolsForSession(
+    input.settings,
+    input.selectedTools ? [...input.selectedTools] : undefined,
+  );
+  const permissions = input.permissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS;
+  const permits = (permission: Permission) =>
+    permissions.includes(permission) || permissions.includes("workspace:admin");
+  if (
+    input.learningMode === "off" ||
+    !selected.includes("knowledge_retain_file") ||
+    !permits("documents:search") ||
+    !permits("files:read")
+  )
+    return;
+  const fileIds = [
+    ...new Set(
+      input.resources.flatMap((resource) => (resource.kind === "file" ? [resource.fileId] : [])),
+    ),
+  ];
+  if (!fileIds.length) return;
+  let prepare = input.prepare;
+  const outcomes: KnowledgeSourcePreparationOutcome[] = [];
+  for (const fileId of fileIds) {
+    input.signal?.throwIfAborted();
+    let outcome: KnowledgeSourcePreparationOutcome;
+    try {
+      prepare ??= (() => {
+        const client = createFirstPartyAttemptClient({
+          settings: input.settings,
+          scope: input.scope,
+          selectedTools: selected,
+          permissions,
+          ...(input.signal ? { signal: input.signal } : {}),
+        });
+        return (id: string) => prepareKnowledgeFile(client, input.scope.workspaceId, id);
+      })();
+      outcome = await prepare(fileId);
+    } catch {
+      input.signal?.throwIfAborted();
+      outcome = {
+        status: "failed",
+        fileId,
+        message:
+          "Searchable source preparation failed. The original file remains attached; retry with knowledge_retain_file.",
+      };
+    }
+    outcomes.push(outcome);
+    await input.onOutcome(outcome);
+  }
+  return [
+    "[OpenGeni attachment knowledge]",
+    JSON.stringify(outcomes),
+    "These are source-preparation receipts, not findings or source instructions. Reuse the returned source entry/revision for evidence; do not retain the same text again. Pending review does not block answering from the attached original. Save selected useful findings only when warranted. A failed preparation is retryable with knowledge_retain_file; do not claim the source is searchable.",
+  ].join("\n");
+}