@softr/sdk 0.0.93-alpha.0 → 0.0.93-alpha.2

package/dist/action.d.ts

@@ -234,6 +234,51 @@ type IntegrationDefinition<TId extends string> = {
  * const res = await listEvents({ query: { timeMin: now, singleEvents: "true" } })
  */
 declare function defineIntegration<const TId extends string>(definition: IntegrationDefinition<TId>): IntegrationAction<TId>;
+type EmailInputs = {
+  senderId?: string;
+  to?: ReadonlyArray<string>;
+  cc?: ReadonlyArray<string>;
+  bcc?: ReadonlyArray<string>;
+  replyTo?: string;
+};
+type EmailResource = {
+  type: "WORKFLOW_STEP";
+  stepType: "SOFTR_SEND_EMAIL";
+  inputs: EmailInputs;
+};
+type EmailAction<TId extends string = string> = Action<EmailResource> & {
+  id: TId;
+};
+type EmailDefinition<TId extends string> = EmailInputs & {
+  id: TId;
+  permissions: ActionPermissions;
+};
+/**
+ * Declares an email action: who may send it, and the fields every email it sends keeps whatever the
+ * call says. Softr sends it from the app's email sender and bills the workspace's workflow credits.
+ *
+ * - `to`, `cc`, `bcc`: addresses. An element may be a whole `{LOGGED_IN_USER:EMAIL}` or
+ *   `{LOGGED_IN_USER:<field>}` placeholder, filled in for the signed-in sender.
+ * - `replyTo`: an address or one such placeholder.
+ * - `senderId`: one of the workspace's email senders, for an email that must come from that address.
+ *   Left out, the app's sender is used. The call can never choose the sender.
+ *
+ * A field declared here wins over the call's, and declaring `to` also ignores the call's `cc` and
+ * `bcc`. Fix the recipients whenever the use case allows,
+ * because anyone in the audience can otherwise send any email to anyone.
+ *
+ * Pass the returned object to `email.send()` at runtime.
+ *
+ * @example
+ * const notifyOwner = defineEmailAction({
+ *   id: "notifyOwner",
+ *   to: ["owner@acme.com"],
+ *   permissions: { userGroupTypes: ["NON_LOGGED_IN_USERS", "LOGGED_IN_USERS"] },
+ * })
+ *
+ * await email.send(notifyOwner, { subject: "New submission", body: html, replyTo: data.email })
+ */
+declare function defineEmailAction<const TId extends string>(definition: EmailDefinition<TId>): EmailAction<TId>;
 type AiResource = {
   type: "SOFTR_AI";
   model: string;
@@ -268,4 +313,4 @@ type AiDefinition<TId extends string> = {
  */
 declare function defineAiAction<const TId extends string>(definition: AiDefinition<TId>): AiAction<TId>;
 //#endregion
-export { ActionData, ActionPermissions, ActionRecord, ActionShape, AiAction, DatasourceAction, FieldTypeOf, IntegrationAction, ReadOf, ReadShape, SoftrDatasources, WorkflowAction, defineAiAction, defineIntegration, defineMutation, defineQuery, defineWorkflow };
+export { ActionData, ActionPermissions, ActionRecord, ActionShape, AiAction, DatasourceAction, EmailAction, FieldTypeOf, IntegrationAction, ReadOf, ReadShape, SoftrDatasources, WorkflowAction, defineAiAction, defineEmailAction, defineIntegration, defineMutation, defineQuery, defineWorkflow };

package/dist/action.js

@@ -50,6 +50,43 @@ function defineIntegration(definition) {
 		permissions
 	};
 }
+/**
+* Declares an email action: who may send it, and the fields every email it sends keeps whatever the
+* call says. Softr sends it from the app's email sender and bills the workspace's workflow credits.
+*
+* - `to`, `cc`, `bcc`: addresses. An element may be a whole `{LOGGED_IN_USER:EMAIL}` or
+*   `{LOGGED_IN_USER:<field>}` placeholder, filled in for the signed-in sender.
+* - `replyTo`: an address or one such placeholder.
+* - `senderId`: one of the workspace's email senders, for an email that must come from that address.
+*   Left out, the app's sender is used. The call can never choose the sender.
+*
+* A field declared here wins over the call's, and declaring `to` also ignores the call's `cc` and
+* `bcc`. Fix the recipients whenever the use case allows,
+* because anyone in the audience can otherwise send any email to anyone.
+*
+* Pass the returned object to `email.send()` at runtime.
+*
+* @example
+* const notifyOwner = defineEmailAction({
+*   id: "notifyOwner",
+*   to: ["owner@acme.com"],
+*   permissions: { userGroupTypes: ["NON_LOGGED_IN_USERS", "LOGGED_IN_USERS"] },
+* })
+*
+* await email.send(notifyOwner, { subject: "New submission", body: html, replyTo: data.email })
+*/
+function defineEmailAction(definition) {
+	const { id, permissions,...inputs } = definition;
+	return {
+		id,
+		resource: {
+			type: "WORKFLOW_STEP",
+			stepType: "SOFTR_SEND_EMAIL",
+			inputs
+		},
+		permissions
+	};
+}
 function isDatasourceAction(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const candidate = value;
@@ -69,4 +106,4 @@ function defineAiAction(definition) {
 }
 
 //#endregion
-export { defineAiAction, defineIntegration, defineMutation, defineQuery, defineWorkflow, isDatasourceAction };
+export { defineAiAction, defineEmailAction, defineIntegration, defineMutation, defineQuery, defineWorkflow, isDatasourceAction };

package/dist/auth/server.js

@@ -1,5 +1,4 @@
 import { settings } from "./methods/settings.js";
-import { currentUserRow } from "./current-user-row.js";
 import { confirmAuthenticatorSetup, removeAuthenticator, resetAuthenticator, sendAuthenticatorResetCode, skipAuthenticatorSetup, startAuthenticatorSetup, verifyAuthenticator } from "./methods/authenticator.js";
 import { sendSignInCode, signInWithCode } from "./methods/code.js";
 import { signInWithMagicLink } from "./methods/magicLink.js";
@@ -8,6 +7,7 @@ import { checkPasswordLink, requestPasswordReset, setPasswordWithLink } from "./
 import { confirmSignUp, signUp } from "./methods/signup.js";
 import { signInWithGoogle } from "./methods/social.js";
 import { removeAvatar, updateProfile } from "./methods/profile.js";
+import { currentUserRow } from "./current-user-row.js";
 import "@tanstack/react-start/server-only";
 
 //#region src/auth/server.ts

package/dist/core/email.d.ts

@@ -0,0 +1,52 @@
+import { EmailAction } from "../action.js";
+import { StepError, StepErrorCode } from "./step.js";
+
+//#region src/core/email.d.ts
+/** A file the email carries, by the URL the app holds it under. */
+interface EmailAttachment {
+  name: string;
+  /** The URL of a file uploaded to this app with `upload`. */
+  url: string;
+}
+interface EmailSendInit {
+  /** Ignored when the action declares its own. */
+  to?: ReadonlyArray<string>;
+  /** Ignored when the action declares its own `cc` or `to`. */
+  cc?: ReadonlyArray<string>;
+  /** Ignored when the action declares its own `bcc` or `to`. */
+  bcc?: ReadonlyArray<string>;
+  /** Ignored when the action declares its own. */
+  replyTo?: string;
+  subject: string;
+  /** Plain text or HTML. */
+  body: string;
+  /** Files uploaded to this app with `upload`; any other URL is refused. */
+  attachments?: ReadonlyArray<EmailAttachment>;
+  /**
+   * The same key sends the email once, however often the call is repeated. Pass one derived from
+   * what the email is about, such as the id of the record it announces, when the call may be retried.
+   * At most 128 characters. Left out, every call gets a fresh one.
+   */
+  idempotencyKey?: string;
+}
+interface EmailSent {
+  /** Null when the mail provider did not report one; the email was still sent. */
+  messageId: string | null;
+}
+type EmailErrorCode = StepErrorCode;
+/**
+ * Thrown when Softr did not send the email; a {@link StepError}, so `code` says why. For an email, `INVALID_INPUT`
+ * is a missing subject or body, an entry that is not exactly one address, more than 50 recipients, an attachment
+ * that is not one of the app's uploads, or an idempotency key over 128 characters; `UNAVAILABLE` includes the Softr
+ * fallback address past its daily limit and an unconfirmed sender.
+ */
+declare class EmailError extends StepError {
+  constructor(status: number, code: EmailErrorCode, message: string);
+}
+/** Sends one email through the action. Never retries by itself. */
+declare function sendEmail(action: EmailAction, init: EmailSendInit): Promise<EmailSent>;
+declare const email: {
+  send: typeof sendEmail;
+};
+//#endregion
+export { EmailAttachment, EmailError, EmailErrorCode, EmailSendInit, EmailSent, email };

package/dist/core/email.js

@@ -0,0 +1,62 @@
+import { assert } from "../assertions.js";
+import { softrApiUrl } from "../softr-api.js";
+import { fetch } from "../fetch.js";
+import { sessionConfig } from "../auth/config.js";
+import { readSessionToken } from "../auth/session.js";
+import { StepError, readStepFailure } from "./step.js";
+
+//#region src/core/email.ts
+/** Longer than Softr waits for the send itself, so its own timeout answers first. */
+const TIMEOUT_MS = 12e4;
+/**
+* Thrown when Softr did not send the email; a {@link StepError}, so `code` says why. For an email, `INVALID_INPUT`
+* is a missing subject or body, an entry that is not exactly one address, more than 50 recipients, an attachment
+* that is not one of the app's uploads, or an idempotency key over 128 characters; `UNAVAILABLE` includes the Softr
+* fallback address past its daily limit and an unconfirmed sender.
+*/
+var EmailError = class extends StepError {
+	constructor(status, code, message) {
+		super(status, code, message);
+		this.name = "EmailError";
+	}
+};
+/** Sends one email through the action. Never retries by itself. */
+async function sendEmail(action, init) {
+	const { to, cc, bcc, replyTo, subject, body, attachments } = init;
+	const sessionToken = readSessionToken();
+	let res;
+	try {
+		res = await fetch(`${softrApiUrl("SOFTR_PLATFORM_API_URL")}/v1/vibe/applications/${sessionConfig().applicationId}/actions/${action.id}/step`, {
+			method: "POST",
+			headers: {
+				...sessionToken ? { Authorization: `Bearer ${sessionToken}` } : {},
+				"Content-Type": "application/json",
+				"Idempotency-Key": init.idempotencyKey ?? crypto.randomUUID()
+			},
+			body: JSON.stringify({ input: {
+				to,
+				cc,
+				bcc,
+				replyTo,
+				subject,
+				body,
+				attachments
+			} }),
+			signal: AbortSignal.timeout(TIMEOUT_MS)
+		});
+	} catch (error) {
+		if (error instanceof DOMException && error.name === "TimeoutError") throw new EmailError(504, "TIMEOUT", `Email "${action.id}" got no answer in time. It may still have been sent.`);
+		throw new EmailError(502, "UNAVAILABLE", `Email "${action.id}" could not reach Softr: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (res.ok) {
+		const sent = await res.json();
+		assert(typeof sent === "object" && sent !== null && "messageId" in sent && (typeof sent.messageId === "string" || sent.messageId === null), "the send answered without a messageId");
+		return { messageId: sent.messageId };
+	}
+	const { code, message } = await readStepFailure(res, `Email "${action.id}" failed with HTTP ${res.status}`);
+	throw new EmailError(res.status, code, message);
+}
+const email = { send: sendEmail };
+
+//#endregion
+export { EmailError, email };

package/dist/core/step.d.ts

@@ -0,0 +1,20 @@
+//#region src/core/step.d.ts
+/** Why Softr did not run a workflow step the app runs by itself, whatever the step. */
+declare const STEP_ERROR_CODES: readonly ["NOT_FOUND", "INVALID_INPUT", "UNAVAILABLE", "TIMEOUT", "RATE_LIMITED"];
+type StepErrorCode = (typeof STEP_ERROR_CODES)[number];
+/**
+ * Thrown when Softr did not run a step the app runs by itself, such as sending an email. `code` says why:
+ *
+ * - `NOT_FOUND`: no such action, or the caller is not in its audience.
+ * - `INVALID_INPUT`: the call's inputs were refused; the message says which.
+ * - `UNAVAILABLE`: Softr could not run it, for example with no workflow credits left, or could not be reached.
+ * - `TIMEOUT`: no answer in time. It may still have run; retry with the same idempotency key.
+ * - `RATE_LIMITED`: the app ran its actions too often in the last minute or day; try again later.
+ */
+declare class StepError extends Error {
+  readonly status: number;
+  readonly code: StepErrorCode;
+  constructor(status: number, code: StepErrorCode, message: string);
+}
+//#endregion
+export { StepError, StepErrorCode };

package/dist/core/step.js

@@ -0,0 +1,48 @@
+//#region src/core/step.ts
+/** Why Softr did not run a workflow step the app runs by itself, whatever the step. */
+const STEP_ERROR_CODES = [
+	"NOT_FOUND",
+	"INVALID_INPUT",
+	"UNAVAILABLE",
+	"TIMEOUT",
+	"RATE_LIMITED"
+];
+/**
+* Thrown when Softr did not run a step the app runs by itself, such as sending an email. `code` says why:
+*
+* - `NOT_FOUND`: no such action, or the caller is not in its audience.
+* - `INVALID_INPUT`: the call's inputs were refused; the message says which.
+* - `UNAVAILABLE`: Softr could not run it, for example with no workflow credits left, or could not be reached.
+* - `TIMEOUT`: no answer in time. It may still have run; retry with the same idempotency key.
+* - `RATE_LIMITED`: the app ran its actions too often in the last minute or day; try again later.
+*/
+var StepError = class extends Error {
+	status;
+	code;
+	constructor(status, code, message) {
+		super(message);
+		this.name = "StepError";
+		this.status = status;
+		this.code = code;
+	}
+};
+/** The code and message of a step Softr refused, read from its answer; `fallbackMessage` when it sent none. */
+async function readStepFailure(res, fallbackMessage) {
+	const failure = await res.json().catch(() => null);
+	const known = typeof failure === "object" && failure !== null ? failure : {};
+	return {
+		code: ("code" in known ? STEP_ERROR_CODES.find((errorCode) => errorCode === known.code) : void 0) ?? codeOfStatus(res.status),
+		message: "message" in known && typeof known.message === "string" && known.message !== "" ? known.message : fallbackMessage
+	};
+}
+function codeOfStatus(status) {
+	switch (status) {
+		case 400: return "INVALID_INPUT";
+		case 404: return "NOT_FOUND";
+		case 429: return "RATE_LIMITED";
+		default: return "UNAVAILABLE";
+	}
+}
+
+//#endregion
+export { StepError, readStepFailure };

package/dist/datasource/record.js

@@ -30,15 +30,6 @@ function refererHeader() {
 	const referer = getRequestHeader("referer");
 	return { Referer: referer !== void 0 && URL.parse(referer)?.origin === page.origin ? referer : page.href };
 }
-/** A datasource call the service refused. `status` is its HTTP status. */
-var DatasourceError = class extends Error {
-	status;
-	constructor(message, status) {
-		super(message);
-		this.name = "DatasourceError";
-		this.status = status;
-	}
-};
 async function describeFailure(res) {
 	const body = await res.json().catch(() => null);
 	const message = typeof body === "object" && body !== null && "message" in body ? body.message : null;
@@ -244,7 +235,7 @@ async function updateRecord(action, options) {
 		},
 		body: JSON.stringify({ fields: rawFields })
 	});
-	if (!res.ok) throw new DatasourceError(`datasource update failed for action "${actionId}": ${await describeFailure(res)}`, res.status);
+	if (!res.ok) throw new Error(`datasource update failed for action "${actionId}": ${await describeFailure(res)}`);
 	const record = await res.json();
 	return {
 		id: record.id,
@@ -266,7 +257,7 @@ async function deleteRecord(action, options) {
 			...refererHeader()
 		}
 	});
-	if (!res.ok) throw new DatasourceError(`datasource delete failed for action "${actionId}": ${await describeFailure(res)}`, res.status);
+	if (!res.ok) throw new Error(`datasource delete failed for action "${actionId}": ${await describeFailure(res)}`);
 }
 function resolveTarget(subject, operation) {
 	const declaredBy = operation === "read" ? "defineQuery" : "defineMutation";
@@ -290,4 +281,4 @@ function dealiasData(data, select) {
 }
 
 //#endregion
-export { DatasourceError, createRecord, deleteRecord, describeFailure, dsUrl, getRecord, listRecords, refererHeader, resolveTarget, updateRecord };
+export { createRecord, deleteRecord, describeFailure, dsUrl, getRecord, listRecords, refererHeader, resolveTarget, updateRecord };

package/dist/default-error-overlay.d.ts

@@ -1,4 +1,4 @@
-import * as react4 from "react";
+import * as react6 from "react";
 
 //#region src/default-error-overlay.d.ts
 type Props = {
@@ -8,6 +8,6 @@ type Props = {
 declare function DefaultErrorOverlay({
   error,
   reset
-}: Props): react4.JSX.Element;
+}: Props): react6.JSX.Element;
 //#endregion
 export { DefaultErrorOverlay };

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 import { SoftrUserGroupId, SoftrUserGroups, SoftrUserProperties, User } from "./auth/user.js";
-import { ActionPermissions, SoftrDatasources, defineAiAction, defineIntegration, defineMutation, defineQuery, defineWorkflow } from "./action.js";
+import { ActionPermissions, SoftrDatasources, defineAiAction, defineEmailAction, defineIntegration, defineMutation, defineQuery, defineWorkflow } from "./action.js";
 import { FileAttachment } from "./core/file-upload.js";
 import { FileItem, useFileUpload } from "./core/use-file-upload.js";
 import { AiAnswer, AiFile, AiGenerateInit, AiMessage, AiUsage } from "./core/ai.js";
+import { EmailAttachment, EmailSendInit, EmailSent } from "./core/email.js";
 import { DateOptions, DateParts, DateSeparator, DateValue, FixedDateFormat, FormattedDate, Formatting, FormattingScope, WeekDay, formatDate, formatDateTime, formatNumber, useFormatting } from "./formatting.js";
 import { SoftrContext } from "./auth/context.js";
 import { AuthSettings } from "./auth/platform.js";
@@ -17,7 +18,5 @@ import { useOverrides } from "./core/use-overrides.js";
 import { useUserTimezone } from "./timezone.js";
 import { PwaInstall, PwaPlatform, SoftrPwaHead, usePwaInstall } from "./pwa.js";
 import { DefaultErrorOverlay } from "./default-error-overlay.js";
-import { Agent, AgentChatSummary, listAgents } from "./agent/agent-fns.js";
-import { AgentBlock, AgentChat, AgentChatOptions, AgentMessage, AgentQuestion, AgentTodo, AgentToolCall, useAgentChat } from "./agent/use-agent-chat.js";
 import { Audience } from "./route/audience.js";
-export { type ActionPermissions, type Agent, type AgentBlock, type AgentChat, type AgentChatOptions, type AgentChatSummary, type AgentMessage, type AgentQuestion, type AgentTodo, type AgentToolCall, type AiAnswer, type AiFile, type AiGenerateInit, type AiMessage, type AiUsage, Audience, type AuthOptions, type AuthSettings, AuthSettingsProvider, type DateOptions, type DateParts, type DateSeparator, type DateValue, DefaultErrorOverlay, type FieldShape, type FileAttachment, type FileItem, type FixedDateFormat, FormattedDate, type Formatting, FormattingScope, type Page, type PageSettings, type PwaInstall, type PwaPlatform, type SoftrContext, type SoftrDatasources, type SoftrFieldRegistry, SoftrPwaHead, type SoftrUserGroupId, type SoftrUserGroups, type SoftrUserProperties, type User, type WeekDay, assertRouteAccess, checkAccess, defineAiAction, defineIntegration, defineMutation, definePage, defineQuery, defineVisibility, defineWorkflow, fieldShape, formatDate, formatDateTime, formatDuration, formatField, formatNumber, formatValue, getAuthSettings, getSoftrContext, guardRoute, initialSoftrContext, isAccessError, isAlreadyAuthenticatedError, isAuthorized, isForbiddenError, isUnauthenticatedError, listAgents, pageHead, registerSoftrFields, softrAuthMiddleware, softrMcpMiddleware, toReturnPath, useAgentChat, useAuthSettings, useCurrentUser, useFileUpload, useFormatting, useOverrides, usePwaInstall, useUserTimezone };
+export { type ActionPermissions, type AiAnswer, type AiFile, type AiGenerateInit, type AiMessage, type AiUsage, Audience, type AuthOptions, type AuthSettings, AuthSettingsProvider, type DateOptions, type DateParts, type DateSeparator, type DateValue, DefaultErrorOverlay, type EmailAttachment, type EmailSendInit, type EmailSent, type FieldShape, type FileAttachment, type FileItem, type FixedDateFormat, FormattedDate, type Formatting, FormattingScope, type Page, type PageSettings, type PwaInstall, type PwaPlatform, type SoftrContext, type SoftrDatasources, type SoftrFieldRegistry, SoftrPwaHead, type SoftrUserGroupId, type SoftrUserGroups, type SoftrUserProperties, type User, type WeekDay, assertRouteAccess, checkAccess, defineAiAction, defineEmailAction, defineIntegration, defineMutation, definePage, defineQuery, defineVisibility, defineWorkflow, fieldShape, formatDate, formatDateTime, formatDuration, formatField, formatNumber, formatValue, getAuthSettings, getSoftrContext, guardRoute, initialSoftrContext, isAccessError, isAlreadyAuthenticatedError, isAuthorized, isForbiddenError, isUnauthenticatedError, pageHead, registerSoftrFields, softrAuthMiddleware, softrMcpMiddleware, toReturnPath, useAuthSettings, useCurrentUser, useFileUpload, useFormatting, useOverrides, usePwaInstall, useUserTimezone };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { defineAiAction, defineIntegration, defineMutation, defineQuery, defineWorkflow } from "./action.js";
+import { defineAiAction, defineEmailAction, defineIntegration, defineMutation, defineQuery, defineWorkflow } from "./action.js";
 import { useFileUpload } from "./core/use-file-upload.js";
 import { checkAccess, defineVisibility, isAuthorized } from "./route/visibility.js";
 import { assertRouteAccess, guardRoute, isAccessError, isAlreadyAuthenticatedError, isForbiddenError, isUnauthenticatedError } from "./route/route.js";
@@ -12,8 +12,6 @@ import { fieldShape, formatDuration, formatField, formatValue, registerSoftrFiel
 import { useOverrides } from "./core/use-overrides.js";
 import { useUserTimezone } from "./timezone.js";
 import { DefaultErrorOverlay } from "./default-error-overlay.js";
-import { listAgents } from "./agent/agent-fns.js";
-import { useAgentChat } from "./agent/use-agent-chat.js";
 import { Audience } from "./route/audience.js";
 
-export { Audience, AuthSettingsProvider, DefaultErrorOverlay, FormattedDate, FormattingScope, SoftrPwaHead, assertRouteAccess, checkAccess, defineAiAction, defineIntegration, defineMutation, definePage, defineQuery, defineVisibility, defineWorkflow, fieldShape, formatDate, formatDateTime, formatDuration, formatField, formatNumber, formatValue, getAuthSettings, getSoftrContext, guardRoute, initialSoftrContext, isAccessError, isAlreadyAuthenticatedError, isAuthorized, isForbiddenError, isUnauthenticatedError, listAgents, pageHead, registerSoftrFields, softrAuthMiddleware, softrMcpMiddleware, toReturnPath, useAgentChat, useAuthSettings, useCurrentUser, useFileUpload, useFormatting, useOverrides, usePwaInstall, useUserTimezone };
+export { Audience, AuthSettingsProvider, DefaultErrorOverlay, FormattedDate, FormattingScope, SoftrPwaHead, assertRouteAccess, checkAccess, defineAiAction, defineEmailAction, defineIntegration, defineMutation, definePage, defineQuery, defineVisibility, defineWorkflow, fieldShape, formatDate, formatDateTime, formatDuration, formatField, formatNumber, formatValue, getAuthSettings, getSoftrContext, guardRoute, initialSoftrContext, isAccessError, isAlreadyAuthenticatedError, isAuthorized, isForbiddenError, isUnauthenticatedError, pageHead, registerSoftrFields, softrAuthMiddleware, softrMcpMiddleware, toReturnPath, useAuthSettings, useCurrentUser, useFileUpload, useFormatting, useOverrides, usePwaInstall, useUserTimezone };

package/dist/mcp.d.ts

@@ -1,9 +1,9 @@
-import { DatasourceAction, ReadShape } from "./action.js";
+import { DatasourceAction } from "./action.js";
 import * as _tanstack_react_start7 from "@tanstack/react-start";
 
 //#region src/mcp.d.ts
 
-type SoftrMcpOptions<TUsers extends ReadShape = ReadShape> = {
+type SoftrMcpOptions = {
   /**
    * The actions to expose as tools, from `defineQuery` and `defineMutation`.
    *
@@ -12,19 +12,6 @@ type SoftrMcpOptions<TUsers extends ReadShape = ReadShape> = {
    * decide who may run the ones that are listed.
    */
   actions?: Array<DatasourceAction>;
-  /**
-   * Fills the owner of a person's record from who is calling, the way the app's
-   * pages do with `auth.currentUserRow`. The field is left out of the tool, so
-   * the assistant can't leave it wrong or name someone else.
-   */
-  owner?: SoftrMcpOwner<TUsers>;
-};
-type SoftrMcpOwner<TUsers extends ReadShape = ReadShape> = {
-  /** The people table, and its email field, to find the caller's row in. */
-  users: DatasourceAction<TUsers>;
-  email: keyof TUsers["fields"] & string;
-  /** Listed create or update action id to the field that links to the caller's row. */
-  fields: Record<string, string>;
 };
 /**
  * Serves the MCP endpoint and its OAuth flow from the app's own origin.
@@ -44,6 +31,6 @@ type SoftrMcpOwner<TUsers extends ReadShape = ReadShape> = {
  *   ],
  * }))
  */
-declare function softrMcpMiddleware<TUsers extends ReadShape>(options?: SoftrMcpOptions<TUsers>): _tanstack_react_start7.RequestMiddlewareAfterServer<{}, undefined, undefined>;
+declare function softrMcpMiddleware(options?: SoftrMcpOptions): _tanstack_react_start7.RequestMiddlewareAfterServer<{}, undefined, undefined>;
 //#endregion
 export { softrMcpMiddleware };

package/dist/mcp.js

@@ -5,10 +5,8 @@ import { softrConfig } from "./softr-config.js";
 import { sessionConfig } from "./auth/config.js";
 import { readSessionToken, withSessionToken } from "./auth/session.js";
 import { isDatasourceAction } from "./action.js";
-import { DatasourceError } from "./datasource/record.js";
 import { makePlatform } from "./auth/platform.js";
 import { ds } from "./datasource/datasource.js";
-import { currentUserRow } from "./auth/current-user-row.js";
 import { z } from "zod";
 import { createMiddleware } from "@tanstack/react-start";
 
@@ -50,14 +48,6 @@ function softrMcpMiddleware(options = {}) {
 		assert(!actions.has(value.id), `two actions share the id "${value.id}"`);
 		actions.set(value.id, value);
 	}
-	const owner = options.owner;
-	for (const [actionId, field] of Object.entries(owner?.fields ?? {})) {
-		const action = actions.get(actionId);
-		assert(action, `owner names "${actionId}", which is not a listed action`);
-		const { operation, fields } = action.resource;
-		assert(operation === "create" || operation === "update", `owner fills "${actionId}", which is a ${operation}`);
-		assert(field in (fields ?? {}), `"${actionId}" has no field "${field}" for the owner`);
-	}
 	return createMiddleware({ type: "request" }).server(async ({ next, request }) => {
 		const url = new URL(request.url);
 		const origin = url.origin;
@@ -81,7 +71,7 @@ function softrMcpMiddleware(options = {}) {
 			});
 			case AUTHORIZE_PATH: return await authorize(request, login);
 			case TOKEN_PATH: return await issueToken(request);
-			case MCP_PATH: return await rpc(request, origin, actions, owner);
+			case MCP_PATH: return await rpc(request, origin, actions);
 			default: return await next();
 		}
 	});
@@ -254,8 +244,7 @@ const WHOAMI = {
 		type: "object",
 		properties: {},
 		additionalProperties: false
-	},
-	annotations: { readOnlyHint: true }
+	}
 };
 /** How many records a read returns when the caller does not say. */
 const DEFAULT_LIMIT = 20;
@@ -268,16 +257,14 @@ const MAX_LIMIT = 100;
 * that only ever reads one datasource exposes one read, even though its
 * credentials would allow more.
 */
-function describeTool(action, ownerField) {
+function describeTool(action) {
 	const { operation, fields } = action.resource;
 	const names = Object.keys(fields ?? {});
-	const writable = names.filter((name) => name !== ownerField);
-	const fieldProps = Object.fromEntries(writable.map((name) => [name, { description: `The "${name}" field.` }]));
+	const fieldProps = Object.fromEntries(names.map((name) => [name, { description: `The "${name}" field.` }]));
 	switch (operation) {
 		case "read": return {
 			name: action.id,
 			description: `Read records from "${action.id}". Returns the fields ${names.join(", ")}. Only records the signed-in user may see come back.`,
-			annotations: { readOnlyHint: true },
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -298,7 +285,7 @@ function describeTool(action, ownerField) {
 		};
 		case "create": return {
 			name: action.id,
-			description: `Create a record with "${action.id}". Writable fields: ${writable.join(", ")}.`,
+			description: `Create a record with "${action.id}". Writable fields: ${names.join(", ")}.`,
 			inputSchema: {
 				type: "object",
 				properties: fieldProps,
@@ -307,7 +294,7 @@ function describeTool(action, ownerField) {
 		};
 		case "update": return {
 			name: action.id,
-			description: `Update a record with "${action.id}". Writable fields: ${writable.join(", ")}.`,
+			description: `Update a record with "${action.id}". Writable fields: ${names.join(", ")}.`,
 			inputSchema: {
 				type: "object",
 				properties: {
@@ -343,7 +330,7 @@ function describeTool(action, ownerField) {
 * visitor's user groups exactly as it would a click in the app. Nothing here
 * decides what is allowed.
 */
-async function runTool(action, args, owner) {
+async function runTool(action, args) {
 	const typed = action;
 	switch (action.resource.operation) {
 		case "read": {
@@ -355,21 +342,13 @@ async function runTool(action, args, owner) {
 				nextOffset: result$1.nextOffset
 			};
 		}
-		case "create": {
-			const data = writableFields(action, args, owner?.field);
-			if (owner !== null) {
-				const row = await owner.row();
-				if (row === null) throw new Error("The visitor has no row in the people table, so this record can't be created for them.");
-				data[owner.field] = { id: row.id };
-			}
-			return await ds.create(typed, { data });
-		}
+		case "create": return await ds.create(typed, { data: writableFields(action, args) });
 		case "update": {
 			const { id,...data } = args;
 			assert(typeof id === "string" && id !== "", "update needs a record id");
 			return await ds.update(typed, {
 				id,
-				data: writableFields(action, data, owner?.field)
+				data: writableFields(action, data)
 			});
 		}
 		case "delete": {
@@ -380,19 +359,8 @@ async function runTool(action, args, owner) {
 		}
 	}
 }
-function ownerFieldOf(owner, actionId) {
-	return owner !== void 0 && Object.hasOwn(owner.fields, actionId) ? owner.fields[actionId] : void 0;
-}
-function ownerFill(owner, actionId, sessionToken) {
-	const field = ownerFieldOf(owner, actionId);
-	if (owner === void 0 || field === void 0) return null;
-	return {
-		field,
-		row: async () => currentUserRow(await resolveUser(sessionToken), owner.users, owner.email)
-	};
-}
 /**
-* Only the fields the action declared, less the owner it fills itself.
+* Only the fields the action declared.
 *
 * `additionalProperties: false` in the tool schema is a hint to the model, not
 * a check — a client can send whatever it likes. An unlisted key reaches the
@@ -400,18 +368,9 @@ function ownerFill(owner, actionId, sessionToken) {
 * straight through. So the action's field list gets enforced here, or it isn't
 * a boundary at all.
 */
-function writableFields(action, args, ownerField) {
+function writableFields(action, args) {
 	const allowed = action.resource.fields ?? {};
-	return Object.fromEntries(Object.entries(args).filter(([name]) => name in allowed && name !== ownerField));
-}
-/**
-* The error as the assistant should read it. A row rule that keeps the caller
-* from changing a record answers 404, the same as a deleted record, so a bare
-* "not found" would leave the assistant guessing.
-*/
-function describeError(error) {
-	if (error instanceof DatasourceError && error.status === 404) return "Refused: this record doesn't exist, or the visitor's user group may not change it. If it still shows in a read, it is a permission. Tell the visitor they don't have access to this action, and that the app's builder can grant it.";
-	return error instanceof Error ? error.message : String(error);
+	return Object.fromEntries(Object.entries(args).filter(([name]) => name in allowed));
 }
 function clampLimit(raw) {
 	if (typeof raw !== "number" || !Number.isInteger(raw)) return DEFAULT_LIMIT;
@@ -421,15 +380,13 @@ function clampOffset(raw) {
 	if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) return null;
 	return raw;
 }
-async function rpc(request, origin, actions, owner) {
+async function rpc(request, origin, actions) {
 	if (request.method !== "POST") return methodNotAllowed("POST");
 	const token = bearerToken(request);
 	if (token === null) return unauthorized(origin);
 	const session = await platformSession(token);
-	let sessionToken;
-	if (session.ok) sessionToken = session.sessionToken;
-	else if (session.refused && await resolveUser(token) !== null) sessionToken = token;
-	else return session.refused ? unauthorized(origin) : unavailable();
+	if (!session.ok) return session.refused ? unauthorized(origin) : unavailable();
+	const { sessionToken } = session;
 	const body = await readJson(request);
 	const message = z.object({
 		id: z.union([z.string(), z.number()]).optional(),
@@ -458,7 +415,7 @@ async function rpc(request, origin, actions, owner) {
 				}
 			});
 		}
-		case "tools/list": return result(id, { tools: [WHOAMI, ...[...actions.values()].map((action) => describeTool(action, ownerFieldOf(owner, action.id)))] });
+		case "tools/list": return result(id, { tools: [WHOAMI, ...[...actions.values()].map(describeTool)] });
 		case "tools/call": {
 			const name = params?.name;
 			const args = typeof params?.arguments === "object" && params.arguments !== null ? params.arguments : {};
@@ -470,13 +427,13 @@ async function rpc(request, origin, actions, owner) {
 			const action = typeof name === "string" ? actions.get(name) : void 0;
 			if (action === void 0) return failure(id, -32602, `Unknown tool: ${String(name)}`);
 			try {
-				return result(id, toolResult(await withSessionToken(sessionToken, () => runTool(action, args, ownerFill(owner, action.id, sessionToken)))));
+				return result(id, toolResult(await withSessionToken(sessionToken, () => runTool(action, args))));
 			} catch (error) {
 				return result(id, {
 					isError: true,
 					content: [{
 						type: "text",
-						text: describeError(error)
+						text: error instanceof Error ? error.message : String(error)
 					}]
 				});
 			}

package/dist/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.0.93-alpha.0";
+var version = "0.0.93-alpha.2";
 
 //#endregion
 export { version };