@agent-native/dispatch 0.2.11 → 0.2.13

package/src/server/lib/workspace-resources-store.ts

@@ -54,7 +54,11 @@ function orgFilter<T extends { ownerEmail: any; orgId: any }>(table: T) {
 
 // ─── Workspace Resources CRUD ──────────────────────────────────
 
-export type WorkspaceResourceKind = "skill" | "instruction" | "agent";
+export type WorkspaceResourceKind =
+  | "skill"
+  | "instruction"
+  | "agent"
+  | "knowledge";
 export type WorkspaceResourceScope = "all" | "selected";
 
 export interface WorkspaceResourceInput {
@@ -66,6 +70,16 @@ export interface WorkspaceResourceInput {
   scope: WorkspaceResourceScope;
 }
 
+export interface WorkspaceResourceOption {
+  id: string;
+  kind: WorkspaceResourceKind;
+  name: string;
+  description: string | null;
+  path: string;
+  scope: WorkspaceResourceScope;
+  updatedAt: number;
+}
+
 export async function listWorkspaceResources(filter?: { kind?: string }) {
   const db = getDb();
   const conditions = [orgFilter(schema.workspaceResources)];
@@ -79,6 +93,21 @@ export async function listWorkspaceResources(filter?: { kind?: string }) {
     .orderBy(desc(schema.workspaceResources.updatedAt));
 }
 
+export async function listWorkspaceResourceOptions(filter?: {
+  kind?: string;
+}): Promise<WorkspaceResourceOption[]> {
+  const resources = await listWorkspaceResources(filter);
+  return resources.map((resource) => ({
+    id: resource.id,
+    kind: resource.kind as WorkspaceResourceKind,
+    name: resource.name,
+    description: resource.description,
+    path: resource.path,
+    scope: resource.scope as WorkspaceResourceScope,
+    updatedAt: resource.updatedAt,
+  }));
+}
+
 export async function getWorkspaceResource(
   resourceId: string,
   ctx: WorkspaceResourceCtx = requireWorkspaceResourceCtx(),
@@ -248,6 +277,13 @@ export async function createResourceGrant(resourceId: string, appId: string) {
   const resource = await getWorkspaceResource(resourceId, ctx);
   if (!resource) throw new Error("Workspace resource not found");
 
+  const activeExisting = (await listResourceGrants({ resourceId, appId })).find(
+    (grant) => grant.status === "active",
+  );
+  if (activeExisting) {
+    return activeExisting;
+  }
+
   const timestamp = now();
   const grantId = id();
   const actor = currentOwnerEmail();
@@ -274,6 +310,42 @@ export async function createResourceGrant(resourceId: string, appId: string) {
   return getResourceGrant(grantId);
 }
 
+export async function grantWorkspaceResourcesToApp(input: {
+  appId: string;
+  resourceIds: string[];
+}) {
+  const uniqueResourceIds = [...new Set(input.resourceIds.filter(Boolean))];
+  if (uniqueResourceIds.length === 0) {
+    return { appId: input.appId, granted: [], skipped: [] };
+  }
+
+  const granted: Array<{ id: string; resourceId: string; appId: string }> = [];
+  const skipped: Array<{ resourceId: string; reason: string }> = [];
+
+  for (const resourceId of uniqueResourceIds) {
+    const resource = await getWorkspaceResource(resourceId).catch(() => null);
+    if (!resource) {
+      skipped.push({ resourceId, reason: "not-found" });
+      continue;
+    }
+    if (resource.scope === "all") {
+      skipped.push({ resourceId, reason: "already-all-apps" });
+      continue;
+    }
+
+    const grant = await createResourceGrant(resourceId, input.appId);
+    if (grant) {
+      granted.push({
+        id: grant.id,
+        resourceId: grant.resourceId,
+        appId: grant.appId,
+      });
+    }
+  }
+
+  return { appId: input.appId, granted, skipped };
+}
+
 export async function revokeResourceGrant(
   grantId: string,
   ctx: WorkspaceResourceCtx = requireWorkspaceResourceCtx(),
@@ -433,12 +505,14 @@ export async function listWorkspaceResourcesOverview() {
   const skills = resources.filter((r) => r.kind === "skill");
   const instructions = resources.filter((r) => r.kind === "instruction");
   const agents = resources.filter((r) => r.kind === "agent");
+  const knowledge = resources.filter((r) => r.kind === "knowledge");
   const activeGrants = grants.filter((g) => g.status === "active");
 
   return {
     skillCount: skills.length,
     instructionCount: instructions.length,
     agentCount: agents.length,
+    knowledgeCount: knowledge.length,
     totalResources: resources.length,
     activeGrantCount: activeGrants.length,
   };

package/src/server/plugins/agent-chat.ts

@@ -29,6 +29,7 @@ Use the standard workspace primitives:
 - Use custom agent profiles in agents/*.md for local spawned work and remote-agents/*.json for remote A2A apps.
 - When answering whether workspace apps expose agent cards or A2A endpoints, call list-workspace-apps with includeAgentCards=true. If you have not requested that probe, absence of agent-card fields means unchecked, not unavailable.
 - When creating a new workspace app, create a separate app under apps/<app-id> with apps/<app-id>/package.json, mount it at /<app-id>, use relative /<app-id> links, never hardcode localhost or dev ports, use shadcn/ui with @tabler/icons-react rather than lucide-react, and ensure the React Router client entry preserves APP_BASE_PATH/VITE_APP_BASE_PATH via appBasePath(). There is no separate workspace app registry to edit.
+- Treat first-party apps such as Mail, Calendar, Analytics, and Dispatch as existing hosted/connected neighbors available through links and A2A/default connected agents. Do not create wrapper apps, child apps, nested routes, or cloned template copies just to give a new app access to them; build only the genuinely new workflow and delegate cross-app work to those existing apps.
 
 When a user asks for something like a digest, reminder, routing rule, or saved behavior:
 - First decide whether it should be a resource, a recurring job, a destination, or a delegated task.

package/src/server/plugins/integrations.ts

@@ -13,6 +13,7 @@ Default posture:
 - Heavily delegate domain work to specialized agents through A2A (call-agent) when another app owns the job. Apps you can delegate to include slides (decks/presentations), analytics (data/dashboards), content (docs/articles), videos (Remotion compositions), forms (form builder), clips (screen recordings), design (visual designs), and images (brand image libraries and generated raster imagery).
 - Use list-connected-agents to see what agents are available before assuming a request must be handled locally.
 - When asked whether workspace apps expose agent cards or A2A endpoints, call list-workspace-apps with includeAgentCards=true. Without that probe, missing agent-card fields mean unchecked, not unavailable.
+- Treat first-party apps such as Mail, Calendar, Analytics, and Dispatch as existing hosted/connected neighbors available through links and A2A/default connected agents. Do not create wrapper apps, child apps, nested routes, or cloned template copies just to give a new app access to them; build only the genuinely new workflow and delegate cross-app work to those existing apps.
 - Keep durable memory and operating instructions in resources rather than ephemeral chat.
 - Reply in the originating thread unless the user explicitly asks you to send to a saved destination.
 
@@ -21,6 +22,7 @@ When a user asks for something:
 - After call-agent returns an answer, RELAY IT DIRECTLY to the user with at most a one-line preface — do not rephrase, summarize, or add commentary. The downstream agent already crafted the answer; your job is delivery, not editing. This minimizes round-trips and keeps the user-visible reply fast.
 - Exception: if the downstream agent reports a missing model/provider credential, do not name exact env vars, Vault keys, tokens, or secrets. Say the target app needs an LLM connection and recommend connecting Builder/managed LLM for that app; keep bring-your-own provider keys as a secondary option only if the user asks.
 - If the user asks to create, build, make, scaffold, or generate an "agent" from Dispatch chat or by tagging @agent-native in Slack, email, or Telegram, first classify the ask. If it is a simple Dispatch-native behavior like a reminder, digest, monitor, routing rule, saved instruction, or recurring workflow, create or update the recurring job/resource/destination in Dispatch. If it is a robust unique product or teammate that needs its own UI, data model, actions, integrations, or domain workflow, treat it as a new workspace app and call start-workspace-app-creation.
+- If a new-app prompt asks for access to Mail, Calendar, Analytics, or similar first-party app data/agents, keep using the existing hosted/connected app and A2A path. Do not ask Builder to scaffold those apps as children of the new app unless the user explicitly asks for a customized fork/copy.
 - If the user explicitly asks for a new app or workspace app, call start-workspace-app-creation with their prompt. Do not satisfy a new-app request by adding a route, page, component, or file inside apps/starter or another existing app unless the user explicitly asks to modify that existing app. If the request is too vague to classify, ask one concise follow-up. If the action returns mode "builder", reply with the Builder branch URL; Builder is responsible for creating the separate workspace app under apps/<app-id>, mounting it at /<app-id>, ensuring apps/<app-id>/package.json exists so Dispatch discovers it, using relative /<app-id> links instead of hardcoded localhost/dev ports, and preserving APP_BASE_PATH/VITE_APP_BASE_PATH via appBasePath() in the React Router client entry. There is no separate workspace app registry to edit. If it returns mode "local-agent", tell the user it is ready for the local code agent and include the returned app path/prompt summary. If it returns mode "coming-soon" or "builder-unavailable", explain the missing Builder setup and ask them to connect/configure Builder.
 - For digests, reminders, or saved behavior, prefer recurring jobs, resources, or destinations over chat replies.
 - Keep responses concise and operational — messaging platforms have character limits.