dopus 0.2.10 → 0.2.12

package/README.md

@@ -142,6 +142,7 @@ export default defineAgent({
 | `input`       | **Required.** A zod schema. The model's arguments are validated before `fn` runs.                        |
 | `confirm`     | `true`, or `(input, ctx) => boolean`, to ask the user before each call. Use it for anything that writes. |
 | `output`      | `(result) => unknown`. Trims the result before the model sees it, for example to drop internal fields.   |
+| `public`      | `true` to offer the tool to users who are not signed in too. Needs `identify` (see below).               |
 
 `ctx` is `{ user, toolCallId, abortSignal }`. `user` is only set when you configure `identify` (see below).
 
@@ -202,6 +203,33 @@ Your part, so an injected instruction cannot cause damage:
 
 We tested this with a real model in a small task-board app. A member wrote a task whose title ordered the assistant to delete other tasks, then an admin's assistant listed the tasks. Claude (claude-sonnet-5-5) did not even request the deletion and pointed out the planted text. If a model did request it, the approval card would still stop it. Other models were not tested this way.
 
+**Signed-in and anonymous users.** Define `identify` and dopus knows who is signed in. When it returns `undefined`, the
+model gets only the tools marked `public: true` (product info, opening hours, "am I signed in?"), and the prompt says
+the rest needs sign-in, so the agent tells the visitor to sign in instead of trying. Member tools are not offered at
+all, so a visitor does not see which features exist. Signed-in users get every tool. An approval for a member tool
+that arrives after the user signed out (in another tab) is not run.
+
+```ts
+defineAgent({
+  tools: {
+    getOpeningHours: defineTool(getOpeningHours, {
+      description: '...',
+      input: z.object({}),
+      public: true,
+    }),
+    listMyOrders: defineTool(() => listMyOrders(), { description: '...', input: z.object({}) }),
+  },
+  identify: async () => {
+    const session = await getSession()
+    return session ? { id: session.userId } : undefined
+  },
+})
+```
+
+This decides what the model sees, nothing more: keep the checks in your server functions. Without `identify` dopus
+cannot tell, so every tool is offered to everyone (and `defineAgent` warns if you used `public`). Anonymous users cost
+model tokens too; rate-limit them in `beforeRequest` (see [Audit log, usage and rate limits](#audit-log-usage-and-rate-limits)).
+
 **Running tools outside the request.** Background jobs and queues lose the request's cookies. For that case, define `identify(request)` to resolve a serialisable user. Tools then receive it as `ctx.user` and can pass it on explicitly. dopus itself always runs tools inside the request; this is for jobs your tools hand off.
 
 ## Prompts

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as PROVIDERS, t as VERSION } from "./version-CWmiLdVn.js";
+import { n as PROVIDERS, t as VERSION } from "./version-gbic1Mgf.js";
 import { execFileSync, spawn } from "node:child_process";
 import { parseArgs } from "node:util";
 import * as p from "@clack/prompts";

package/dist/index.d.ts

@@ -66,6 +66,12 @@ interface ToolOptions<SCHEMA extends z.ZodType, RESULT> {
    * the job finishes the agent is told, reads the result with another of your tools, and continues.
    */
   job?: (result: Awaited<RESULT>) => string;
+  /**
+   * Also offered to users who are not signed in. Needs `identify` in the agent config: when it returns
+   * `undefined`, only public tools are given to the model, so features that need an account stay out of sight.
+   * This only decides which tools the model sees; keep the permission checks in your server functions.
+   */
+  public?: boolean;
 }
 type ToolFunction<INPUT, RESULT> = (input: INPUT, ctx: ToolContext) => RESULT;
 interface DopusTool<SCHEMA extends z.ZodType = z.ZodType, RESULT = unknown> {
@@ -235,5 +241,5 @@ interface ProviderInfo {
 }
 /** Verified against @ai-sdk/openai@4.0.111, @ai-sdk/anthropic@4.0.99, @ai-sdk/google@4.0.114. */
 export declare const PROVIDERS: Record<ProviderId, ProviderInfo>;
-export declare const VERSION = "0.2.10";
+export declare const VERSION = "0.2.12";
 export type { AgentConfig, AgentUser, ClientContext, ConfirmOption, DopusTool, DopusToolSet, FinishEvent, HandlerOptions, PromptLayers, ProviderId, ProviderInfo, RuntimeContext, ToolCallEvent, ToolContext, ToolOptions };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as PROVIDERS, t as VERSION } from "./version-CWmiLdVn.js";
+import { n as PROVIDERS, t as VERSION } from "./version-gbic1Mgf.js";
 import { convertToModelMessages, createUIMessageStreamResponse, getToolName, isStepCount, isToolUIPart, safeValidateUIMessages, streamText, toUIMessageStream, tool } from "ai";
 // src/job.ts
 /**
@@ -82,7 +82,8 @@ const CACHE_BREAKPOINT = { anthropic: { cacheControl: { type: "ephemeral" } } };
 const RUNTIME_LABELS = {
 	locale: "Response language",
 	role: "User role",
-	page: "Current page (reported by the browser)"
+	page: "Current page (reported by the browser)",
+	access: "Access"
 };
 /** Picks `ko-KR`, then `ko`, from the locale notes. */
 function pickLocaleNotes(notes, locale) {
@@ -194,8 +195,27 @@ function defineAgent(config) {
 		if (!isDopusTool(value)) throw new TypeError(`defineAgent: tools.${name} must be created with defineTool()`);
 		if (!/^[a-zA-Z0-9_-]{1,64}$/.test(name)) throw new TypeError(`defineAgent: tool name "${name}" must match [a-zA-Z0-9_-]{1,64}`);
 	}
+	if (!config.identify && Object.values(config.tools).some((t) => t.options.public)) console.warn("[dopus] `public` tools need `identify` in defineAgent: without it dopus cannot tell who is signed in, so every tool is offered to everyone.");
 	return config;
 }
+/**
+* The tools this request may use: all of them for a signed-in user, only `public` ones for an anonymous user.
+* Without `identify` dopus cannot tell who is signed in, so every tool is offered (the server functions decide).
+*/
+function visibleTools(config, user) {
+	if (!config.identify || user) return {
+		tools: config.tools,
+		hidden: []
+	};
+	const tools = {};
+	const hidden = [];
+	for (const [name, t] of Object.entries(config.tools)) if (t.options.public) tools[name] = t;
+	else hidden.push(name);
+	return {
+		tools,
+		hidden
+	};
+}
 /** Runs a user hook; a failing hook is reported but never breaks the chat. */
 async function runHook(hook, event, report) {
 	if (!hook) return;
@@ -277,6 +297,10 @@ function readClientContext(body, request) {
 		page: clean(raw.page, 200)
 	};
 }
+/** Reason recorded for a confirmation of a tool that needs sign-in, answered by a user who is not signed in. */
+const SIGN_IN_REASON = "Not run: this needs the user to be signed in, and they are not (anymore). Tell them to sign in first.";
+/** Runtime prompt line for anonymous users when some tools are hidden from them. */
+const SIGNED_OUT_NOTE = "Not signed in. Only features that work without an account are available; if the user asks for something else, tell them to sign in first.";
 /** Reason recorded for a confirmation the conversation moved past (the model reads it). */
 const NOT_RUN_REASON = "Not run: the user sent a new message instead of approving it. If they still want it, call the tool again so they can approve it.";
 /**
@@ -286,11 +310,11 @@ const NOT_RUN_REASON = "Not run: the user sent a new message instead of approvin
 * approved-but-unrun call makes every later request fail with a missing tool result. A stale approval is never
 * executed: the user has moved on, so it may no longer be what they want.
 */
-function settleStaleApprovals(messages) {
+function settleStaleApprovals(messages, hidden = []) {
 	const last = messages.length - 1;
 	return messages.map((message, index) => {
-		if (message.role !== "assistant" || index === last) return message;
-		const pending = (part) => isToolUIPart(part) && (part.state === "approval-requested" || part.state === "approval-responded");
+		if (message.role !== "assistant") return message;
+		const pending = (part) => isToolUIPart(part) && (part.state === "approval-requested" || part.state === "approval-responded") && (index !== last || hidden.includes(getToolName(part)));
 		if (!message.parts.some(pending)) return message;
 		return {
 			...message,
@@ -303,7 +327,7 @@ function settleStaleApprovals(messages) {
 					approval: {
 						id: part.approval.id,
 						approved: false,
-						reason: declined ? part.approval.reason : NOT_RUN_REASON
+						reason: declined ? part.approval.reason : index === last ? SIGN_IN_REASON : NOT_RUN_REASON
 					}
 				};
 			})
@@ -343,14 +367,15 @@ function createAgentHandler(config, options = {}) {
 			return errorResponse(400, "Request body must be JSON");
 		}
 		const user = await config.identify?.(request);
-		const { tools, toolApproval } = buildTools(config.tools, {
+		const visible = visibleTools(config, user);
+		const { tools, toolApproval } = buildTools(visible.tools, {
 			user,
 			report,
 			onToolCall: config.onToolCall
 		});
 		const validated = await safeValidateUIMessages({ messages: body?.messages });
 		if (!validated.success) return errorResponse(400, "Invalid messages");
-		const messages = settleStaleApprovals(validated.data);
+		const messages = settleStaleApprovals(validated.data, visible.hidden);
 		if (messages.some((message) => message.role === "user" && message.parts.some((part) => part.type === "text" && part.text.length > maxMessageChars))) return errorResponse(413, "Message is too long");
 		if (messages.some((message) => message.parts.some((part) => part.type === "data-dopus-job" && !isJobId(part.data?.id)))) return errorResponse(400, "Invalid job notice");
 		const early = await config.beforeRequest?.({
@@ -372,6 +397,7 @@ function createAgentHandler(config, options = {}) {
 		const client = readClientContext(body, request);
 		const runtime = {
 			...client,
+			...visible.hidden.length > 0 ? { access: SIGNED_OUT_NOTE } : {},
 			...await config.runtime?.(request, {
 				user,
 				client

package/dist/{version-CWmiLdVn.js → version-gbic1Mgf.js}

@@ -27,5 +27,5 @@ const PROVIDERS = {
 	}
 };
 // src/version.ts
-const VERSION = "0.2.10";
+const VERSION = "0.2.12";
 export { PROVIDERS as n, VERSION as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dopus",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "A lightweight agent for Next.js: your existing server functions become its tools, run with the signed-in user's permissions.",
   "license": "MIT",
   "author": "akodm",