@ghuri/agents 0.0.0-stage → 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1995 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/agent.ts
+import {
+  anonymousUser as anonymousUser2,
+  ImproperlyConfigured as ImproperlyConfigured3,
+  tryGetContext as tryGetContext6
+} from "@ghuri/core";
+import { NotAuthenticated, PermissionDenied } from "@ghuri/rest";
+import {
+  tool as aiTool,
+  createUIMessageStreamResponse,
+  generateText,
+  jsonSchema,
+  stepCountIs,
+  streamText
+} from "ai";
+
+// src/memory.ts
+import { apps as apps2 } from "@ghuri/core";
+
+// src/errors.ts
+import { GhuriError } from "@ghuri/core";
+var AgentError = class extends GhuriError {
+};
+var ToolError = class extends AgentError {
+  /** HTTP-like status (403, 400, 404…) when the error came from a view. */
+  status;
+  /** Structured details (DRF error body, validation errors…). */
+  detail;
+  constructor(message, opts = {}) {
+    super(message, { cause: opts.cause });
+    this.status = opts.status;
+    this.detail = opts.detail;
+  }
+  toJSON() {
+    return {
+      error: this.message,
+      ...this.status !== void 0 ? { status: this.status } : {},
+      ...this.detail !== void 0 ? { detail: this.detail } : {}
+    };
+  }
+};
+var ToolInputError = class extends ToolError {
+  constructor(message, detail) {
+    super(message, { status: 400, detail });
+  }
+};
+var UnknownToolError = class extends AgentError {
+};
+var ModelResolutionError = class extends AgentError {
+};
+
+// src/models.ts
+import { apps, tryGetContext } from "@ghuri/core";
+import {
+  CASCADE,
+  CharField,
+  DateTimeField,
+  ForeignKey,
+  JSONField,
+  Model,
+  UUIDField
+} from "@ghuri/orm";
+function userModel() {
+  const label = tryGetContext()?.settings.AUTH_USER_MODEL ?? "auth.User";
+  return apps.getModel(label);
+}
+function newConversationId() {
+  return crypto.randomUUID();
+}
+function emptyMetadata() {
+  return {};
+}
+var Conversation = class extends Model({
+  id: new UUIDField({ primaryKey: true, default: newConversationId, editable: false }),
+  user: new ForeignKey(userModel, {
+    null: true,
+    blank: true,
+    onDelete: CASCADE,
+    relatedName: "agentConversations"
+  }),
+  agent: new CharField({ maxLength: 100, dbIndex: true }),
+  title: new CharField({ maxLength: 200, blank: true, default: "" }),
+  metadata: new JSONField({ default: emptyMetadata, blank: true }),
+  createdAt: new DateTimeField({ autoNowAdd: true }),
+  updatedAt: new DateTimeField({ autoNow: true })
+}) {
+  static Meta = { appLabel: "agents", ordering: ["-updatedAt"], verboseName: "conversation" };
+  toString() {
+    return this.title || String(this.id);
+  }
+};
+var MESSAGE_ROLES = ["system", "user", "assistant", "tool"];
+var Message = class extends Model({
+  conversation: new ForeignKey(() => Conversation, { onDelete: CASCADE, relatedName: "messages" }),
+  role: new CharField({ maxLength: 20, choices: MESSAGE_ROLES.map((r) => [r, r]) }),
+  content: new JSONField({ null: true }),
+  createdAt: new DateTimeField({ autoNowAdd: true })
+}) {
+  static Meta = { appLabel: "agents", ordering: ["id"], verboseName: "message" };
+};
+
+// src/memory.ts
+var ConversationNotFound = class extends ToolError {
+  constructor(message) {
+    super(message, { status: 404 });
+  }
+};
+function memoryAvailable() {
+  try {
+    return apps2.ready && apps2.isInstalled("agents");
+  } catch {
+    return false;
+  }
+}
+function ownerPk(user) {
+  return user?.isAuthenticated ? user.pk : null;
+}
+function isOwner(conversation, user) {
+  const owner = conversation.userId ?? null;
+  const pk = ownerPk(user);
+  if (owner === null || pk === null) return owner === null && pk === null;
+  return String(owner) === String(pk);
+}
+async function getConversation(agent, id, user) {
+  let conv = null;
+  try {
+    conv = await Conversation.objects.filter({ id: String(id), agent }).first();
+  } catch {
+    conv = null;
+  }
+  if (!conv || !isOwner(conv, user)) throw new ConversationNotFound(`Conversation '${id}' not found.`);
+  return conv;
+}
+async function createConversation(agent, user, opts = {}) {
+  const pk = ownerPk(user);
+  return Conversation.objects.create({
+    agent,
+    title: (opts.title ?? "").slice(0, 200),
+    metadata: opts.metadata ?? {},
+    ...pk !== null ? { userId: pk } : {}
+  });
+}
+async function loadMessages(conversation) {
+  const id = typeof conversation === "string" ? conversation : String(conversation.pk);
+  const rows = await Message.objects.filter({ conversation: id }).orderBy("id");
+  return rows.map((r) => ({ role: r.role, content: r.content }));
+}
+function jsonContent(content) {
+  return JSON.parse(
+    JSON.stringify(content, (_k, v) => {
+      if (v instanceof Uint8Array) {
+        let s = "";
+        for (const b of v) s += String.fromCharCode(b);
+        return btoa(s);
+      }
+      if (v instanceof URL) return v.toString();
+      return v;
+    })
+  );
+}
+async function saveMessages(conversation, messages) {
+  if (!messages.length) return;
+  await Message.objects.bulkCreate(
+    messages.map(
+      (m) => new Message({
+        conversationId: String(conversation.pk),
+        role: m.role,
+        content: jsonContent(m.content)
+      })
+    )
+  );
+  await conversation.save({ updateFields: ["updatedAt"] });
+}
+function titleFrom(input) {
+  let text = "";
+  if (typeof input === "string") text = input;
+  else {
+    const first = input.find((m) => m.role === "user");
+    const c = first?.content;
+    if (typeof c === "string") text = c;
+    else if (Array.isArray(c)) text = c.map((p) => p.type === "text" ? p.text : "").join(" ");
+  }
+  text = text.replace(/\s+/g, " ").trim();
+  return text.length > 80 ? `${text.slice(0, 77)}...` : text;
+}
+
+// src/providers.ts
+import { tryGetContext as tryGetContext3 } from "@ghuri/core";
+
+// src/settings.ts
+import { tryGetContext as tryGetContext2 } from "@ghuri/core";
+import { IsAuthenticated } from "@ghuri/rest";
+var DEFAULT_MAX_STEPS = 10;
+function agentsSettings() {
+  const s = tryGetContext2()?.settings.AGENTS;
+  return s && typeof s === "object" ? s : {};
+}
+function defaultPermissionClasses() {
+  return agentsSettings().PERMISSION_CLASSES ?? [IsAuthenticated];
+}
+
+// src/providers.ts
+var KEY = /* @__PURE__ */ Symbol.for("ghuri.agents.providers");
+var g = globalThis;
+if (!g[KEY]) g[KEY] = /* @__PURE__ */ new Map();
+var providers = g[KEY];
+function registerProvider(name, factory) {
+  providers.set(name, factory);
+}
+function unregisterProvider(name) {
+  return providers.delete(name);
+}
+function getProviders() {
+  return [...providers.keys()];
+}
+function processEnv(name) {
+  const p = globalThis.process;
+  return p?.env?.[name];
+}
+function apiKey(ctx, envName) {
+  const v = ctx.config.apiKey ?? ctx.env?.[envName] ?? processEnv(envName);
+  return typeof v === "string" && v ? v : void 0;
+}
+function missingPackage(pkg, provider, cause) {
+  return new ModelResolutionError(
+    `The '${provider}:' model provider needs the '${pkg}' package: npm install ${pkg}`,
+    { cause }
+  );
+}
+function withoutKnown(config) {
+  const { apiKey: _k, ...rest } = config;
+  return rest;
+}
+registerProvider("workers-ai", async (modelId, ctx) => {
+  const bindingName = ctx.settings.AI_BINDING ?? "AI";
+  const binding = ctx.env?.[bindingName];
+  if (!binding) {
+    throw new ModelResolutionError(
+      `Workers AI binding '${bindingName}' not found in env. Add "ai": { "binding": "${bindingName}" } to wrangler.jsonc or set AGENTS.AI_BINDING.`
+    );
+  }
+  let mod;
+  try {
+    mod = await import("workers-ai-provider");
+  } catch (err) {
+    throw missingPackage("workers-ai-provider", "workers-ai", err);
+  }
+  return mod.createWorkersAI({ ...withoutKnown(ctx.config), binding })(modelId);
+});
+registerProvider("anthropic", async (modelId, ctx) => {
+  let mod;
+  try {
+    mod = await import("@ai-sdk/anthropic");
+  } catch (err) {
+    throw missingPackage("@ai-sdk/anthropic", "anthropic", err);
+  }
+  return mod.createAnthropic({ ...withoutKnown(ctx.config), apiKey: apiKey(ctx, "ANTHROPIC_API_KEY") })(
+    modelId
+  );
+});
+registerProvider("openai", async (modelId, ctx) => {
+  let mod;
+  try {
+    mod = await import("@ai-sdk/openai");
+  } catch (err) {
+    throw missingPackage("@ai-sdk/openai", "openai", err);
+  }
+  return mod.createOpenAI({ ...withoutKnown(ctx.config), apiKey: apiKey(ctx, "OPENAI_API_KEY") })(modelId);
+});
+function isLanguageModel(value) {
+  return !!value && typeof value === "object" && typeof value.modelId === "string" && (typeof value.doGenerate === "function" || typeof value.doStream === "function");
+}
+async function resolveModel(model, env) {
+  const settings = agentsSettings();
+  const m = model ?? settings.DEFAULT_MODEL;
+  if (!m) {
+    throw new ModelResolutionError(
+      "No model configured: set `model` on the agent (e.g. 'workers-ai:@cf/meta/llama-3.3-70b-instruct-fp8-fast') or AGENTS.DEFAULT_MODEL."
+    );
+  }
+  if (typeof m !== "string") return m;
+  const i = m.indexOf(":");
+  if (i <= 0) {
+    throw new ModelResolutionError(
+      `Model '${m}' must be '<provider>:<model-id>' (providers: ${getProviders().join(", ")}).`
+    );
+  }
+  const name = m.slice(0, i);
+  const modelId = m.slice(i + 1);
+  const factory = providers.get(name);
+  if (!factory) {
+    throw new ModelResolutionError(
+      `Unknown model provider '${name}' in '${m}' (registered: ${getProviders().join(", ")}). Use registerProvider().`
+    );
+  }
+  return factory(modelId, {
+    env: env ?? tryGetContext3()?.env ?? {},
+    settings,
+    config: settings.PROVIDERS?.[name] ?? {}
+  });
+}
+
+// src/queue.ts
+import {
+  anonymousUser,
+  apps as apps3,
+  ImproperlyConfigured,
+  onQueue,
+  tryGetContext as tryGetContext4
+} from "@ghuri/core";
+var AGENT_JOB_TYPE = "ghuri.agents.run";
+async function enqueueRun(agent, input, opts = {}) {
+  const name = opts.binding ?? agentsSettings().QUEUE_BINDING ?? "AGENTS_QUEUE";
+  const queue = tryGetContext4()?.env?.[name];
+  if (!queue || typeof queue.send !== "function") {
+    throw new ImproperlyConfigured(
+      `Queue producer binding '${name}' not found: add it to wrangler.jsonc ("queues": { "producers": [...] }) or set AGENTS.QUEUE_BINDING.`
+    );
+  }
+  let conversationId = opts.conversationId ?? void 0;
+  if (!conversationId && agent.memory !== false && memoryAvailable()) {
+    const conv = await createConversation(agent.getName(), opts.user, { title: titleFrom(input) });
+    conversationId = String(conv.pk);
+  }
+  const job = {
+    type: AGENT_JOB_TYPE,
+    agent: agent.getName(),
+    input,
+    userId: ownerPk(opts.user),
+    ...conversationId ? { conversationId } : {},
+    ...opts.context ? { context: opts.context } : {}
+  };
+  await queue.send(job);
+  return { conversationId };
+}
+async function loadJobUser(userId) {
+  if (userId === null || userId === void 0) return anonymousUser;
+  const label = tryGetContext4()?.settings.AUTH_USER_MODEL ?? "auth.User";
+  const model = apps3.getModel(label);
+  return model.objects.get({ pk: userId });
+}
+function consumeAgentQueue(queue, create) {
+  return onQueue(queue, async (batch) => {
+    for (const msg of batch.messages) {
+      const job = msg.body;
+      if (!job || job.type !== AGENT_JOB_TYPE) continue;
+      try {
+        const agent = create(job.agent);
+        const user = await loadJobUser(job.userId);
+        await agent.run(job.input, {
+          user,
+          conversationId: job.conversationId ?? null,
+          context: job.context
+        });
+        msg.ack();
+      } catch (err) {
+        console.error(`[ghuri.agents] queued run of '${job.agent}' failed:`, err);
+        msg.retry();
+      }
+    }
+  });
+}
+
+// src/tools/execute.ts
+import { HttpError, runWithContext, tryGetContext as tryGetContext5, ValidationError } from "@ghuri/core";
+import { APIException } from "@ghuri/rest";
+function inContext(ctx, fn) {
+  if (!ctx || tryGetContext5() === ctx) return fn();
+  return runWithContext(ctx, fn);
+}
+function isDebug() {
+  return !!tryGetContext5()?.settings.DEBUG;
+}
+function toToolError(err, toolName) {
+  if (err instanceof ToolError) return err;
+  if (err instanceof APIException) {
+    return new ToolError(`${err.message || "Request failed."} (HTTP ${err.statusCode})`, {
+      status: err.statusCode,
+      cause: err
+    });
+  }
+  if (err instanceof HttpError) {
+    return new ToolError(`${err.message} (HTTP ${err.status})`, {
+      status: err.status,
+      cause: err
+    });
+  }
+  if (err instanceof ValidationError) {
+    const detail = err.messageDict ?? err.messages;
+    return new ToolError(`Validation failed: ${JSON.stringify(detail ?? err.message)}`, {
+      status: 400,
+      detail,
+      cause: err
+    });
+  }
+  if (err instanceof Error && err.name === "AbortError") return new ToolError("Aborted.", { cause: err });
+  console.error(`[ghuri.agents] tool ${toolName ?? ""} failed:`, err);
+  const message = isDebug() && err instanceof Error ? err.message : "The tool failed with an internal error.";
+  return new ToolError(message, { status: 500, cause: err });
+}
+async function runTool(tool2, args, ctx) {
+  try {
+    const input = tool2.parse ? tool2.parse(args) : args ?? {};
+    return await tool2.execute(input, ctx);
+  } catch (err) {
+    throw toToolError(err, tool2.name);
+  }
+}
+
+// src/tools/tool.ts
+import { ImproperlyConfigured as ImproperlyConfigured2 } from "@ghuri/core";
+
+// src/tools/schema.ts
+import { z } from "zod";
+function sanitizeToolName(name) {
+  const s = name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+  return (s || "tool").slice(0, 64);
+}
+function snakeCase(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+function isZodSchema(value) {
+  return !!value && typeof value === "object" && "_zod" in value && typeof value.safeParse === "function";
+}
+function toJSONSchema(input) {
+  if (input === void 0 || input === null) return { type: "object", properties: {} };
+  if (isZodSchema(input)) {
+    const schema = z.toJSONSchema(input, { io: "input", unrepresentable: "any" });
+    delete schema.$schema;
+    return schema;
+  }
+  if (typeof input === "object") return { ...input };
+  throw new TypeError("Tool input must be a Zod schema or a JSON Schema object.");
+}
+function makeParser(input) {
+  if (isZodSchema(input)) {
+    return (value) => {
+      const res = input.safeParse(value ?? {});
+      if (!res.success) {
+        const issues = res.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }));
+        const summary = issues.map((i) => i.path ? `${i.path}: ${i.message}` : i.message).join("; ");
+        throw new ToolInputError(`Invalid arguments: ${summary}`, issues);
+      }
+      return res.data;
+    };
+  }
+  return (value) => {
+    if (value === void 0 || value === null) return {};
+    if (typeof value !== "object" || Array.isArray(value))
+      throw new ToolInputError("Tool arguments must be a JSON object.");
+    return value;
+  };
+}
+function cleanInputSchema(schema) {
+  if (!schema) return { type: "object", properties: {} };
+  const { title: _t, ...rest } = schema;
+  return { ...rest, type: "object", properties: { ...schema.properties ?? {} } };
+}
+function parametersToProperties(params) {
+  const properties = {};
+  const required = [];
+  for (const p of params) {
+    if (p.in && p.in !== "query") continue;
+    const name = String(p.name);
+    properties[name] = {
+      ...p.schema ?? { type: "string" },
+      ...p.description ? { description: String(p.description) } : {}
+    };
+    if (p.required) required.push(name);
+  }
+  return { properties, required };
+}
+
+// src/tools/tool.ts
+var TOOL = /* @__PURE__ */ Symbol.for("ghuri.agents.tool");
+var TOOL_OPTIONS = /* @__PURE__ */ Symbol.for("ghuri.agents.toolOptions");
+function mark(fn, name, opts) {
+  if (typeof fn !== "function") throw new TypeError("@tool() can only decorate methods.");
+  fn[TOOL] = { ...opts, name: opts.name ?? name };
+}
+function legacyMethodDescriptor(target, key, descriptor) {
+  if (typeof key !== "string" && typeof key !== "symbol") return void 0;
+  if (!target || typeof target !== "object" && typeof target !== "function") return void 0;
+  if (descriptor !== void 0 && descriptor !== target) return void 0;
+  const real = Object.getOwnPropertyDescriptor(target, key);
+  return real && typeof real.value === "function" ? real : void 0;
+}
+function tool(opts) {
+  if (!opts || typeof opts.description !== "string")
+    throw new TypeError("tool() requires a `description` string.");
+  const decorator = ((value, context, descriptor) => {
+    if (descriptor && typeof descriptor.value === "function") {
+      mark(descriptor.value, String(context), opts);
+      return descriptor;
+    }
+    if (typeof value === "function") {
+      const name = context && typeof context === "object" && "name" in context ? String(context.name) : value.name;
+      mark(value, name, opts);
+      return value;
+    }
+    const legacy = legacyMethodDescriptor(value, context, descriptor);
+    if (legacy) {
+      mark(legacy.value, String(context), opts);
+      return legacy;
+    }
+    throw new TypeError("@tool() can only decorate methods.");
+  });
+  Object.defineProperty(decorator, TOOL_OPTIONS, { value: opts });
+  return decorator;
+}
+function isToolDecorator(value) {
+  return typeof value === "function" && TOOL_OPTIONS in value;
+}
+function defineTool(name, opts, execute) {
+  return {
+    name: sanitizeToolName(opts.name ?? name),
+    description: opts.description,
+    inputSchema: toJSONSchema(opts.input),
+    ...opts.output ? { outputSchema: opts.output } : {},
+    ...opts.annotations ? { annotations: opts.annotations } : {},
+    parse: makeParser(opts.input),
+    execute
+  };
+}
+function standaloneTool(decorator, key) {
+  const opts = decorator[TOOL_OPTIONS];
+  if (typeof opts.execute !== "function") {
+    throw new ImproperlyConfigured2(
+      `tool('${opts.name ?? key ?? opts.description}') has no \`execute\`: use it as a method decorator or pass execute.`
+    );
+  }
+  const name = opts.name ?? key;
+  if (!name) throw new ImproperlyConfigured2(`A standalone tool needs a \`name\` (${opts.description}).`);
+  return defineTool(name, opts, opts.execute);
+}
+function collectDeclaredTools(instance) {
+  const cls = instance.constructor;
+  const found = /* @__PURE__ */ new Map();
+  const chain = [];
+  for (let p = Object.getPrototypeOf(instance); p && p !== Object.prototype; p = Object.getPrototypeOf(p))
+    chain.unshift(p);
+  for (const proto of chain) {
+    for (const key of Object.getOwnPropertyNames(proto)) {
+      if (key === "constructor") continue;
+      const fn = Object.getOwnPropertyDescriptor(proto, key)?.value;
+      if (typeof fn === "function" && fn[TOOL]) {
+        const opts = fn[TOOL];
+        found.set(
+          key,
+          defineTool(opts.name ?? key, opts, (input, ctx) => instance[key](input, ctx))
+        );
+      }
+    }
+  }
+  const staticChain = [];
+  for (let c = cls; c && c !== Function.prototype; c = Object.getPrototypeOf(c)) staticChain.unshift(c);
+  for (const c of staticChain) {
+    if (!Object.hasOwn(c, "tools") || !c.tools || typeof c.tools !== "object" || Array.isArray(c.tools))
+      continue;
+    for (const [key, spec] of Object.entries(c.tools)) {
+      const opts = isToolDecorator(spec) ? spec[TOOL_OPTIONS] : spec && typeof spec === "object" && typeof spec.description === "string" ? spec : void 0;
+      if (!opts) continue;
+      if (typeof opts.execute === "function") {
+        found.set(key, defineTool(opts.name ?? key, opts, opts.execute));
+        continue;
+      }
+      if (typeof instance[key] !== "function") {
+        throw new ImproperlyConfigured2(`${c.name}.tools.${key}: the class has no method named '${key}'.`);
+      }
+      found.set(
+        key,
+        defineTool(opts.name ?? key, opts, (input, ctx) => instance[key](input, ctx))
+      );
+    }
+  }
+  return [...found.values()];
+}
+
+// src/tools/types.ts
+var Toolkit = class {
+};
+function isToolkit(value) {
+  return !!value && typeof value.getTools === "function";
+}
+function isAgentTool(value) {
+  return !!value && typeof value === "object" && typeof value.name === "string" && typeof value.execute === "function" && typeof value.inputSchema === "object";
+}
+
+// src/agent.ts
+function deriveName(cls) {
+  const base = cls.name.replace(/Agent$/, "") || cls.name || "agent";
+  return base.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^A-Za-z0-9_-]+/g, "-").toLowerCase();
+}
+function errorText(error) {
+  if (error instanceof Error) return error.message;
+  return typeof error === "string" ? error : JSON.stringify(error);
+}
+function toolCallsFrom(content) {
+  const calls = /* @__PURE__ */ new Map();
+  for (const part of content) {
+    if (part.type === "tool-call") {
+      calls.set(part.toolCallId, { toolCallId: part.toolCallId, toolName: part.toolName, input: part.input });
+    } else if (part.type === "tool-result" || part.type === "tool-error") {
+      const rec = calls.get(part.toolCallId) ?? {
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        input: part.input
+      };
+      if (part.type === "tool-result") rec.output = part.output;
+      else rec.error = errorText(part.error);
+      calls.set(part.toolCallId, rec);
+    }
+  }
+  return [...calls.values()];
+}
+var Agent = class {
+  /** Name used for conversations, URLs and MCP (`ask_<name>`); default: class name minus `Agent`, kebab-case. */
+  static agentName;
+  /** Shown to MCP clients for the `ask_<name>` tool. */
+  static description;
+  /** Tools implemented by methods of the same name, without decorators: `{ refund: tool({...}) }`. */
+  static tools;
+  /** `'provider:model-id'` or an AI SDK `LanguageModel` (default `AGENTS.DEFAULT_MODEL`). */
+  model;
+  /** System instructions, or a function of the run context. */
+  instructions;
+  /** Toolkits and tools (plus `@tool` methods and `static tools`). */
+  tools;
+  /** REST permission classes checked for HTTP / MCP access (default `AGENTS.PERMISSION_CLASSES`). */
+  permissionClasses;
+  /** Maximum model steps (tool round trips) per run (default `AGENTS.MAX_STEPS`, 10). */
+  maxSteps;
+  temperature;
+  maxOutputTokens;
+  /** Provider-specific options passed to the AI SDK (`{ anthropic: { thinking: … } }`). */
+  providerOptions;
+  /** Use conversation memory when the `agents` app is installed (default true). */
+  memory = true;
+  /** Set by `AgentRouter.register(name, …)`. */
+  agentName;
+  /** `new this().run(input, opts)`. */
+  static run(input, opts) {
+    return new this().run(input, opts);
+  }
+  getName() {
+    const cls = this.constructor;
+    return this.agentName ?? (Object.hasOwn(cls, "agentName") ? cls.agentName : void 0) ?? deriveName(cls);
+  }
+  getDescription() {
+    const cls = this.constructor;
+    return cls.description ?? `Ask the ${this.getName()} agent. It answers in natural language.`;
+  }
+  getPermissionClasses() {
+    return this.permissionClasses ?? defaultPermissionClasses();
+  }
+  /** System instructions for a run (override for dynamic instructions). */
+  async getInstructions(ctx) {
+    const i = this.instructions;
+    return typeof i === "function" ? await i.call(this, ctx) : i;
+  }
+  /** All tools of this agent, normalized (toolkits expanded, declared methods bound). */
+  getTools() {
+    const out = [];
+    const add = (entry, key) => {
+      if (isToolDecorator(entry)) out.push(standaloneTool(entry, key));
+      else if (isAgentTool(entry)) out.push(key && !entry.name ? { ...entry, name: key } : entry);
+      else if (isToolkit(entry)) out.push(...entry.getTools());
+      else
+        throw new ImproperlyConfigured3(
+          `${this.constructor.name}.tools: unsupported entry ${key ? `'${key}'` : String(entry)} (use toolkits, tool({...}) or AgentTool objects).`
+        );
+    };
+    const tools = this.tools;
+    if (Array.isArray(tools)) for (const t of tools) add(t);
+    else if (tools && typeof tools === "object") for (const [k, t] of Object.entries(tools)) add(t, k);
+    out.push(...collectDeclaredTools(this));
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of out) {
+      if (seen.has(t.name))
+        throw new ImproperlyConfigured3(`${this.constructor.name} has two tools named '${t.name}'.`);
+      seen.add(t.name);
+    }
+    return out;
+  }
+  /** Check `permissionClasses` for `user` (`NotAuthenticated` / `PermissionDenied` from `@ghuri/rest`). */
+  async checkPermissions(user, request) {
+    const req = request ?? { user, auth: null, method: "POST", successfulAuthenticator: null };
+    for (const P of this.getPermissionClasses()) {
+      const p = new P();
+      if (!await p.hasPermission(req, this)) {
+        if (!user.isAuthenticated) throw new NotAuthenticated();
+        throw new PermissionDenied(p.message ?? null, p.code ?? null);
+      }
+    }
+  }
+  /** AI SDK tool set for a run: validation, `onToolCall`, context and error normalization included. */
+  buildToolSet(ctx, tools = this.getTools()) {
+    const ghuri = tryGetContext6();
+    const set = {};
+    for (const t of tools) {
+      set[t.name] = aiTool({
+        description: t.description,
+        inputSchema: jsonSchema(t.inputSchema, {
+          validate: (value) => {
+            try {
+              return { success: true, value: t.parse ? t.parse(value) : value };
+            } catch (error) {
+              return { success: false, error: toToolError(error, t.name) };
+            }
+          }
+        }),
+        execute: (input, opts) => inContext(ghuri, async () => {
+          const toolCtx = {
+            user: ctx.user,
+            agent: this,
+            conversationId: ctx.conversationId,
+            toolCallId: opts.toolCallId,
+            signal: opts.abortSignal ?? ctx.signal,
+            request: ctx.request
+          };
+          try {
+            await this.onToolCall?.({ toolName: t.name, toolCallId: opts.toolCallId, input }, ctx);
+            return await t.execute(input, toolCtx);
+          } catch (err) {
+            throw toToolError(err, t.name);
+          }
+        })
+      });
+    }
+    return set;
+  }
+  async prepare(input, opts) {
+    const user = opts.user ?? anonymousUser2;
+    if (opts.checkPermissions) await this.checkPermissions(user, opts.request);
+    const model = await resolveModel(this.model);
+    const agentName = this.getName();
+    const useMemory = opts.memory ?? (this.memory !== false && memoryAvailable());
+    let conversation;
+    let history = [];
+    if (opts.conversationId) {
+      if (!memoryAvailable()) {
+        throw new ImproperlyConfigured3(
+          "conversationId requires the agents app: add AgentsConfig to INSTALLED_APPS."
+        );
+      }
+      conversation = await getConversation(agentName, opts.conversationId, user);
+      history = await loadMessages(conversation);
+    } else if (useMemory) {
+      conversation = await createConversation(agentName, user, { title: opts.title ?? titleFrom(input) });
+    }
+    const newMessages = typeof input === "string" ? [{ role: "user", content: input }] : [...input];
+    const ctx = {
+      agent: this,
+      agentName,
+      user,
+      input,
+      conversation,
+      conversationId: conversation ? String(conversation.pk) : void 0,
+      messages: [...history, ...newMessages],
+      newMessages,
+      signal: opts.signal,
+      request: opts.request,
+      extra: opts.context ?? {}
+    };
+    await this.beforeRun?.(ctx);
+    const instructions = await this.getInstructions(ctx);
+    return { ctx, model, instructions, tools: this.buildToolSet(ctx), ghuri: tryGetContext6() };
+  }
+  callSettings(p) {
+    return {
+      model: p.model,
+      ...p.instructions ? { instructions: p.instructions } : {},
+      messages: p.ctx.messages,
+      tools: p.tools,
+      stopWhen: stepCountIs(this.maxSteps ?? agentsSettings().MAX_STEPS ?? DEFAULT_MAX_STEPS),
+      ...this.temperature !== void 0 ? { temperature: this.temperature } : {},
+      ...this.maxOutputTokens !== void 0 ? { maxOutputTokens: this.maxOutputTokens } : {},
+      ...this.providerOptions ? { providerOptions: this.providerOptions } : {},
+      ...p.ctx.signal ? { abortSignal: p.ctx.signal } : {}
+    };
+  }
+  async finish(p, r) {
+    const messages = [...p.ctx.newMessages, ...r.responseMessages];
+    if (p.ctx.conversation) await saveMessages(p.ctx.conversation, messages);
+    const result = {
+      text: r.text,
+      messages,
+      toolCalls: toolCallsFrom(r.content),
+      usage: r.usage,
+      finishReason: r.finishReason,
+      steps: r.steps,
+      conversationId: p.ctx.conversationId
+    };
+    await this.afterRun?.(result, p.ctx);
+    return result;
+  }
+  /**
+   * Run the agent to completion (tool loop included). Tool failures (permission denied, validation, not
+   * found) are returned to the model as tool errors; the run itself only throws for model / config errors.
+   */
+  async run(input, opts = {}) {
+    const p = await this.prepare(input, opts);
+    const res = await generateText(this.callSettings(p));
+    return this.finish(p, {
+      text: res.text,
+      responseMessages: res.responseMessages,
+      content: res.content,
+      usage: res.usage,
+      finishReason: res.finishReason,
+      steps: res.steps.length
+    });
+  }
+  /**
+   * Run in the background through a Cloudflare Queue (`AGENTS.QUEUE_BINDING`); a consumer registered with
+   * `AgentRouter.consumeQueue()` performs the run. Returns the conversation id to poll.
+   */
+  async enqueue(input, opts = {}) {
+    return enqueueRun(this, input, opts);
+  }
+  /**
+   * Stream a run. Use `toUIMessageStreamResponse()` for AI SDK UI (`useChat`) / SSE clients, or `textStream`.
+   * The conversation is saved when the stream finishes; `await stream.done` for the final result.
+   */
+  async stream(input, opts = {}) {
+    const p = await this.prepare(input, opts);
+    const result = streamText(this.callSettings(p));
+    const done = (async () => {
+      const [text, responseMessages, content, usage, finishReason, steps] = await Promise.all([
+        result.text,
+        result.responseMessages,
+        result.content,
+        result.usage,
+        result.finishReason,
+        result.steps
+      ]);
+      return inContext(
+        p.ghuri,
+        () => this.finish(p, {
+          text,
+          responseMessages,
+          content,
+          usage,
+          finishReason,
+          steps: steps.length
+        })
+      );
+    })();
+    done.catch(() => {
+    });
+    p.ghuri?.executionCtx?.waitUntil(done.catch(() => {
+    }));
+    return new AgentStream(result, done, p.ctx.conversationId);
+  }
+};
+var AgentStream = class {
+  constructor(result, done, conversationId) {
+    this.result = result;
+    this.done = done;
+    this.conversationId = conversationId;
+  }
+  result;
+  done;
+  conversationId;
+  /** Plain text deltas. */
+  get textStream() {
+    return this.result.textStream;
+  }
+  /**
+   * AI SDK UI message stream chunks (`start`, `text-delta`, `tool-input-available`, `tool-output-available`,
+   * `finish`…). The `start` chunk carries `messageMetadata: { conversationId }`. The stream closes only after
+   * the conversation was saved.
+   */
+  toUIMessageStream() {
+    const conversationId = this.conversationId;
+    const done = this.done;
+    const stream = this.result.toUIMessageStream({
+      messageMetadata: ({ part }) => part.type === "start" && conversationId ? { conversationId } : void 0,
+      onError: (error) => errorText(error)
+    });
+    return stream.pipeThrough(
+      new TransformStream({
+        async flush(controller) {
+          try {
+            await done;
+          } catch (err) {
+            controller.enqueue({ type: "error", errorText: errorText(err) });
+          }
+        }
+      })
+    );
+  }
+  /** An SSE `Response` in the AI SDK UI message stream protocol (header `x-conversation-id`). */
+  toUIMessageStreamResponse(init = {}) {
+    return createUIMessageStreamResponse({
+      status: init.status,
+      headers: {
+        ...this.conversationId ? { "x-conversation-id": this.conversationId } : {},
+        ...init.headers ?? {}
+      },
+      stream: this.toUIMessageStream()
+    });
+  }
+};
+
+// src/apps.ts
+import { AppConfig, tryGetContext as tryGetContext7 } from "@ghuri/core";
+import { Migration as Migration2, migrationsFromModule } from "@ghuri/orm/migrations";
+
+// src/migrations/index.ts
+var migrations_exports = {};
+__export(migrations_exports, {
+  m0001_initial: () => initial_default,
+  migrations: () => migrations
+});
+
+// src/migrations/0001_initial.ts
+import { Migration, operations as ops } from "@ghuri/orm/migrations";
+var initial_default = new Migration({
+  initial: true,
+  dependencies: [["auth", "0001_initial"]],
+  operations: [
+    ops.CreateModel({
+      name: "Conversation",
+      fields: {
+        id: {
+          type: "UUIDField",
+          primaryKey: true,
+          default: { callable: "newConversationId" },
+          editable: false
+        },
+        user: {
+          type: "ForeignKey",
+          to: "auth.User",
+          onDelete: "CASCADE",
+          null: true,
+          blank: true,
+          dbIndex: true,
+          relatedName: "agentConversations"
+        },
+        agent: { type: "CharField", maxLength: 100, dbIndex: true },
+        title: { type: "CharField", maxLength: 200, blank: true, default: "" },
+        metadata: { type: "JSONField", blank: true, default: { callable: "emptyMetadata" } },
+        createdAt: { type: "DateTimeField", autoNowAdd: true },
+        updatedAt: { type: "DateTimeField", autoNow: true }
+      },
+      options: { ordering: ["-updatedAt"], verboseName: "conversation" }
+    }),
+    ops.CreateModel({
+      name: "Message",
+      fields: {
+        id: { type: "BigAutoField", primaryKey: true },
+        conversation: {
+          type: "ForeignKey",
+          to: "agents.Conversation",
+          onDelete: "CASCADE",
+          dbIndex: true,
+          relatedName: "messages"
+        },
+        role: {
+          type: "CharField",
+          maxLength: 20,
+          choices: [
+            ["system", "system"],
+            ["user", "user"],
+            ["assistant", "assistant"],
+            ["tool", "tool"]
+          ]
+        },
+        content: { type: "JSONField", null: true },
+        createdAt: { type: "DateTimeField", autoNowAdd: true }
+      },
+      options: { ordering: ["id"], verboseName: "message" }
+    })
+  ]
+});
+
+// src/migrations/index.ts
+var migrations = {
+  "0001_initial": initial_default
+};
+
+// src/apps.ts
+function migrationsForUserModel() {
+  const label = tryGetContext7()?.settings.AUTH_USER_MODEL;
+  if (!label || label.toLowerCase() === "auth.user") return migrations_exports;
+  const userApp = label.split(".")[0];
+  const out = {};
+  for (const [name, m] of migrationsFromModule(migrations_exports) ?? []) {
+    const operations = m.operations.map((op) => {
+      if (!op.fields) return op;
+      const fields = Object.fromEntries(
+        Object.entries(op.fields).map(([k, f]) => {
+          const to = f?.options?.to ?? f?.to;
+          if (typeof to !== "string" || to.toLowerCase() !== "auth.user") return [k, f];
+          return [k, f.options ? { ...f, options: { ...f.options, to: label } } : { ...f, to: label }];
+        })
+      );
+      return Object.assign(Object.create(Object.getPrototypeOf(op)), op, { fields });
+    });
+    const dependencies = m.dependencies.filter((d) => d[0] !== "auth");
+    if (!dependencies.some((d) => d[0] === userApp)) dependencies.push([userApp, "__first__"]);
+    const adapted = new Migration2({ dependencies, operations, initial: m.initial });
+    adapted.name = m.name || name;
+    out[adapted.name] = adapted;
+  }
+  return { migrations: out };
+}
+function appPath() {
+  const meta = import.meta;
+  if (!meta.dirname || !/[\\/]src$/.test(meta.dirname) || !/\.[cm]?ts$/.test(meta.filename ?? ""))
+    return void 0;
+  return meta.dirname;
+}
+var AgentsConfig = class extends AppConfig {
+  name = "@ghuri/agents";
+  label = "agents";
+  verboseName = "Agents";
+  path = appPath();
+  migrations = migrationsForUserModel();
+  models = { Conversation, Message };
+};
+
+// src/http.ts
+import { ImproperlyConfigured as ImproperlyConfigured5, path as path2, tryGetContext as tryGetContext9 } from "@ghuri/core";
+import {
+  APIException as APIException2,
+  APIResponse as APIResponse2,
+  APIView as APIView2,
+  JSONRenderer as JSONRenderer2,
+  NotAuthenticated as NotAuthenticated2,
+  NotFound,
+  ValidationError as RestValidationError
+} from "@ghuri/rest";
+
+// src/mcp.ts
+import { getHost, ImproperlyConfigured as ImproperlyConfigured4, path, tryGetContext as tryGetContext8 } from "@ghuri/core";
+import {
+  APIResponse,
+  APIView,
+  JSONRenderer
+} from "@ghuri/rest";
+var MCP_PROTOCOL_VERSIONS = ["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"];
+var MCP_LATEST_PROTOCOL_VERSION = MCP_PROTOCOL_VERSIONS[0];
+var JSONRPC = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  /** Server-defined: authentication / authorization failures. */
+  UNAUTHORIZED: -32001
+};
+function isAgentClass(source) {
+  return source === Agent || source.prototype instanceof Agent;
+}
+function agentFactory(source) {
+  return isAgentClass(source) ? () => new source() : source;
+}
+function isPlainObject(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function errorResponse(id, code, message, data) {
+  return { jsonrpc: "2.0", id, error: { code, message, ...data !== void 0 ? { data } : {} } };
+}
+function asJson(value) {
+  return value === void 0 ? null : JSON.parse(JSON.stringify(value));
+}
+var McpServer = class {
+  opts;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  /** All exposed tools (toolkits expanded, agents as `ask_<name>`). */
+  getTools() {
+    const out = [];
+    const add = (entry, key) => {
+      if (isToolDecorator(entry)) out.push(standaloneTool(entry, key));
+      else if (isAgentTool(entry)) out.push(entry);
+      else if (isToolkit(entry)) out.push(...entry.getTools());
+      else throw new TypeError(`MCP tools: unsupported entry ${key ? `'${key}'` : String(entry)}.`);
+    };
+    const tools = this.opts.tools;
+    if (Array.isArray(tools)) for (const t of tools) add(t);
+    else if (tools) for (const [k, t] of Object.entries(tools)) add(t, k);
+    for (const [name, factory] of Object.entries(this.opts.agents ?? {})) out.push(agentTool(name, factory));
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of out) {
+      if (seen.has(t.name)) throw new ImproperlyConfigured4(`MCP server has two tools named '${t.name}'.`);
+      seen.add(t.name);
+    }
+    return out;
+  }
+  /** `tools/list` entries. */
+  listTools() {
+    return this.getTools().map((t) => ({
+      name: t.name,
+      ...t.annotations?.title ? { title: t.annotations.title } : {},
+      description: t.description,
+      inputSchema: t.inputSchema,
+      ...t.outputSchema ? { outputSchema: t.outputSchema } : {},
+      ...t.annotations ? { annotations: t.annotations } : {}
+    }));
+  }
+  /** `tools/call`: run a tool as `ctx.user`. Tool failures are results with `isError: true`. */
+  async callTool(name, args, ctx) {
+    const tool2 = this.getTools().find((t) => t.name === name);
+    if (!tool2) throw new McpError(JSONRPC.INVALID_PARAMS, `Unknown tool: ${name}`);
+    try {
+      const out = await runTool(tool2, args, { user: ctx.user, request: ctx.request, signal: ctx.signal });
+      if (typeof out === "string") return { content: [{ type: "text", text: out }], isError: false };
+      const json = asJson(out);
+      return {
+        content: [{ type: "text", text: JSON.stringify(json) }],
+        structuredContent: isPlainObject(json) ? json : { result: json },
+        isError: false
+      };
+    } catch (err) {
+      const e = err instanceof ToolError ? err : new ToolError(String(err));
+      const detail = e.detail !== void 0 ? `
+${JSON.stringify(e.detail)}` : "";
+      return { content: [{ type: "text", text: `${e.message}${detail}` }], isError: true };
+    }
+  }
+  /** `initialize` result. */
+  initializeResult(params) {
+    const requested = typeof params.protocolVersion === "string" ? params.protocolVersion : void 0;
+    const protocolVersion = requested && MCP_PROTOCOL_VERSIONS.includes(requested) ? requested : MCP_LATEST_PROTOCOL_VERSION;
+    return {
+      protocolVersion,
+      capabilities: { tools: { listChanged: false } },
+      serverInfo: {
+        name: this.opts.name ?? "ghuri",
+        version: this.opts.version ?? "0.1.0",
+        ...this.opts.title ? { title: this.opts.title } : {}
+      },
+      ...this.opts.instructions ? { instructions: this.opts.instructions } : {}
+    };
+  }
+  /** Handle one JSON-RPC message; `null` for notifications and client responses (nothing to send). */
+  async handleMessage(message, ctx) {
+    if (!isPlainObject(message) || message.jsonrpc !== "2.0") {
+      const id2 = isPlainObject(message) && isValidId(message.id) ? message.id : null;
+      return errorResponse(id2, JSONRPC.INVALID_REQUEST, "Invalid Request");
+    }
+    const hasId = "id" in message && message.id !== void 0;
+    if (typeof message.method !== "string") {
+      if (("result" in message || "error" in message) && hasId) return null;
+      return errorResponse(
+        isValidId(message.id) ? message.id : null,
+        JSONRPC.INVALID_REQUEST,
+        "Invalid Request"
+      );
+    }
+    if (!hasId) return null;
+    if (!isValidId(message.id) || message.id === null)
+      return errorResponse(null, JSONRPC.INVALID_REQUEST, "Invalid Request: id must be a string or number");
+    const id = message.id;
+    const params = message.params === void 0 ? {} : message.params;
+    if (!isPlainObject(params)) return errorResponse(id, JSONRPC.INVALID_PARAMS, "params must be an object");
+    try {
+      const result = await this.dispatch(message.method, params, ctx);
+      return { jsonrpc: "2.0", id, result };
+    } catch (err) {
+      if (err instanceof McpError) return errorResponse(id, err.code, err.message, err.data);
+      console.error("[ghuri.agents] MCP request failed:", err);
+      const debug = !!tryGetContext8()?.settings.DEBUG;
+      return errorResponse(
+        id,
+        JSONRPC.INTERNAL_ERROR,
+        debug && err instanceof Error ? err.message : "Internal error"
+      );
+    }
+  }
+  async dispatch(method, params, ctx) {
+    switch (method) {
+      case "initialize":
+        return this.initializeResult(params);
+      case "ping":
+        return {};
+      case "tools/list":
+        return { tools: this.listTools() };
+      case "tools/call": {
+        if (typeof params.name !== "string")
+          throw new McpError(JSONRPC.INVALID_PARAMS, "tools/call requires a tool name");
+        return this.callTool(params.name, params.arguments ?? {}, ctx);
+      }
+      case "resources/list":
+        return { resources: [] };
+      case "resources/templates/list":
+        return { resourceTemplates: [] };
+      case "prompts/list":
+        return { prompts: [] };
+      case "logging/setLevel":
+        return {};
+      default:
+        throw new McpError(JSONRPC.METHOD_NOT_FOUND, `Method not found: ${method}`);
+    }
+  }
+  /** Handle a parsed POST body (single message or batch). Returns the HTTP status and JSON body (or none). */
+  async handleBody(body, ctx) {
+    if (Array.isArray(body)) {
+      if (!body.length)
+        return { status: 400, body: errorResponse(null, JSONRPC.INVALID_REQUEST, "Empty batch") };
+      const responses = [];
+      for (const m of body) {
+        const r2 = await this.handleMessage(m, ctx);
+        if (r2) responses.push(r2);
+      }
+      return responses.length ? { status: 200, body: responses } : { status: 202 };
+    }
+    const r = await this.handleMessage(body, ctx);
+    if (!r) return { status: 202 };
+    return { status: 200, body: r };
+  }
+  /** The Streamable HTTP endpoint view. */
+  asView() {
+    return McpView.asView({ mcpServer: this });
+  }
+  /** URL patterns: mount with `path('mcp/', server.urls)`. */
+  get urls() {
+    return [path("", this.asView(), { name: "mcp" })];
+  }
+};
+var McpError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+  code;
+  data;
+};
+function isValidId(id) {
+  return id === null || typeof id === "string" || typeof id === "number" && Number.isFinite(id);
+}
+function agentTool(name, source) {
+  const factory = agentFactory(source);
+  const probe = factory();
+  return {
+    name: sanitizeToolName(`ask_${name}`),
+    description: probe.getDescription(),
+    inputSchema: {
+      type: "object",
+      properties: {
+        message: { type: "string", description: "Your message to the agent." },
+        conversationId: {
+          type: "string",
+          description: "Continue a previous conversation (the conversationId returned by an earlier call)."
+        }
+      },
+      required: ["message"]
+    },
+    annotations: { title: `Ask ${name}`, readOnlyHint: false, openWorldHint: false },
+    parse(input) {
+      if (!isPlainObject(input) || typeof input.message !== "string" || !input.message.trim())
+        throw new ToolError("'message' is required.", { status: 400 });
+      if (input.conversationId !== void 0 && typeof input.conversationId !== "string")
+        throw new ToolError("'conversationId' must be a string.", { status: 400 });
+      return input;
+    },
+    async execute(input, ctx) {
+      const agent = factory();
+      await agent.checkPermissions(ctx.user, ctx.request);
+      const r = await agent.run(input.message, {
+        user: ctx.user,
+        conversationId: input.conversationId ?? null,
+        request: ctx.request,
+        signal: ctx.signal
+      });
+      return { text: r.text, ...r.conversationId ? { conversationId: r.conversationId } : {} };
+    }
+  };
+}
+function sameOrigin(request, origin) {
+  let url;
+  try {
+    url = new URL(origin);
+  } catch {
+    return false;
+  }
+  const host = getHost(request.c);
+  if (url.host === host) return true;
+  const trusted = tryGetContext8()?.settings.CSRF_TRUSTED_ORIGINS ?? [];
+  return trusted.some(
+    (t) => t === origin || t.includes("*") && new RegExp(`^${t.replace(/[.]/g, "\\.").replace("*", "[^/]+")}$`).test(origin)
+  );
+}
+var McpView = class extends APIView {
+  rendererClasses = [JSONRenderer];
+  getAuthenticators() {
+    const classes = this.mcpServer.opts.authenticationClasses ?? agentsSettings().AUTHENTICATION_CLASSES;
+    return classes ? classes.map((A) => new A()) : super.getAuthenticators();
+  }
+  getPermissions() {
+    return (this.mcpServer.opts.permissionClasses ?? defaultPermissionClasses()).map((P) => new P());
+  }
+  performContentNegotiation(request, _force = false) {
+    return super.performContentNegotiation(request, true);
+  }
+  /** Authentication / permission failures keep their HTTP status (401 + WWW-Authenticate) with a JSON-RPC body. */
+  async handleException(exc) {
+    const res = await super.handleException(exc);
+    const detail = res.data?.detail;
+    res.data = errorResponse(
+      null,
+      res.status === 401 || res.status === 403 ? JSONRPC.UNAUTHORIZED : JSONRPC.INTERNAL_ERROR,
+      detail !== void 0 && detail !== null ? String(detail) : "Request failed"
+    );
+    return res;
+  }
+  async post(request) {
+    const origin = request.header("origin");
+    if (origin && !this.mcpServer.opts.allowAnyOrigin && !sameOrigin(request, origin)) {
+      return new APIResponse(errorResponse(null, JSONRPC.INVALID_REQUEST, "Origin not allowed"), {
+        status: 403
+      });
+    }
+    const version = request.header("mcp-protocol-version");
+    if (version && !MCP_PROTOCOL_VERSIONS.includes(version)) {
+      return new APIResponse(
+        errorResponse(null, JSONRPC.INVALID_REQUEST, `Unsupported MCP-Protocol-Version: ${version}`),
+        { status: 400 }
+      );
+    }
+    let body;
+    try {
+      body = request.data;
+    } catch {
+      return new APIResponse(errorResponse(null, JSONRPC.PARSE_ERROR, "Parse error"), { status: 400 });
+    }
+    if (body === void 0 || isPlainObject(body) && !Object.keys(body).length) {
+      return new APIResponse(errorResponse(null, JSONRPC.INVALID_REQUEST, "Invalid Request"), { status: 400 });
+    }
+    const { status, body: out } = await this.mcpServer.handleBody(body, {
+      user: request.user,
+      request,
+      signal: request.raw.signal
+    });
+    if (out === void 0) return new Response(null, { status });
+    return new APIResponse(out, { status });
+  }
+  async get() {
+    return new Response(null, { status: 405, headers: { Allow: "POST" } });
+  }
+  async delete() {
+    return new Response(null, { status: 405, headers: { Allow: "POST" } });
+  }
+};
+
+// src/http.ts
+var ModelUnavailable = class extends APIException2 {
+  static statusCode = 503;
+  static defaultDetail = "The agent's language model is not available.";
+  static defaultCode = "model_unavailable";
+};
+function agentAuthenticationClasses() {
+  return agentsSettings().AUTHENTICATION_CLASSES;
+}
+var AgentBaseView = class extends APIView2 {
+  _agent;
+  rendererClasses = [JSONRenderer2];
+  /** The agent instance serving this request. */
+  get agent() {
+    this._agent ??= this.agentRouter.create(this.agentName);
+    return this._agent;
+  }
+  getAuthenticators() {
+    const classes = this.authenticationClasses ?? agentAuthenticationClasses();
+    return classes ? classes.map((A) => new A()) : super.getAuthenticators();
+  }
+  getPermissions() {
+    if (this.permissionClasses) return super.getPermissions();
+    return this.agent.getPermissionClasses().map((P) => new P());
+  }
+  // Never 406: SSE clients send `Accept: text/event-stream`; errors are rendered as JSON.
+  performContentNegotiation(request, _force = false) {
+    return super.performContentNegotiation(request, true);
+  }
+  requireMemory() {
+    if (!memoryAvailable()) throw new NotFound("Conversation memory is not enabled (install AgentsConfig).");
+  }
+};
+function wantsStream(request) {
+  const q = request.queryParams.get("stream");
+  if (q !== null) return ["1", "true", "yes"].includes(q.toLowerCase());
+  return (request.header("accept") ?? "").includes("text/event-stream");
+}
+function lastUserText(messages) {
+  if (!Array.isArray(messages)) return void 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m?.role !== "user") continue;
+    if (typeof m.content === "string") return m.content;
+    if (Array.isArray(m.parts))
+      return m.parts.filter((p) => p?.type === "text").map((p) => p.text).join("");
+  }
+  return void 0;
+}
+var AgentChatView = class extends AgentBaseView {
+  async post(request) {
+    const body = request.data ?? {};
+    const message = typeof body.message === "string" ? body.message : lastUserText(body.messages);
+    if (typeof message !== "string" || !message.trim())
+      throw new RestValidationError({ message: ["This field is required."] });
+    const conversationId = body.conversationId ?? null;
+    if (conversationId !== null && typeof conversationId !== "string")
+      throw new RestValidationError({ conversationId: ["Must be a string."] });
+    const input = message;
+    const opts = { user: request.user, conversationId, request };
+    try {
+      if (wantsStream(request)) {
+        const stream = await this.agent.stream(input, opts);
+        return stream.toUIMessageStreamResponse();
+      }
+      const r = await this.agent.run(input, opts);
+      return new APIResponse2({
+        conversationId: r.conversationId ?? null,
+        text: r.text,
+        toolCalls: r.toolCalls,
+        usage: r.usage,
+        finishReason: r.finishReason
+      });
+    } catch (err) {
+      if (err instanceof ConversationNotFound) throw new NotFound(err.message);
+      if (err instanceof ModelResolutionError)
+        throw new ModelUnavailable(tryGetContext9()?.settings.DEBUG ? err.message : void 0);
+      throw err;
+    }
+  }
+};
+function conversationJSON(c) {
+  return {
+    id: String(c.pk),
+    agent: c.agent,
+    title: c.title,
+    metadata: c.metadata ?? {},
+    createdAt: c.createdAt,
+    updatedAt: c.updatedAt
+  };
+}
+var ConversationListView = class extends AgentBaseView {
+  async get(request) {
+    this.requireMemory();
+    if (!request.user.isAuthenticated) throw new NotAuthenticated2();
+    const limit = Math.min(Math.max(Number(request.query.limit) || 50, 1), 200);
+    const offset = Math.max(Number(request.query.offset) || 0, 0);
+    const qs = Conversation.objects.filter({ agent: this.agentName, user: request.user.pk });
+    const [count, rows] = await Promise.all([
+      qs.count(),
+      qs.orderBy("-updatedAt").slice(offset, offset + limit)
+    ]);
+    return new APIResponse2({ count, results: rows.map(conversationJSON) });
+  }
+};
+var ConversationDetailView = class extends AgentBaseView {
+  async conversation(request, id) {
+    this.requireMemory();
+    if (!request.user.isAuthenticated) throw new NotAuthenticated2();
+    try {
+      return await getConversation(this.agentName, id, request.user);
+    } catch (err) {
+      if (err instanceof ConversationNotFound) throw new NotFound(err.message);
+      throw err;
+    }
+  }
+  async get(request, kwargs) {
+    const conv = await this.conversation(request, String(kwargs.id));
+    const rows = await Message.objects.filter({ conversation: String(conv.pk) }).orderBy("id");
+    return new APIResponse2({
+      ...conversationJSON(conv),
+      messages: rows.map((m) => ({ id: m.pk, role: m.role, content: m.content, createdAt: m.createdAt }))
+    });
+  }
+  async delete(request, kwargs) {
+    const conv = await this.conversation(request, String(kwargs.id));
+    await conv.delete();
+    return new APIResponse2(null, { status: 204 });
+  }
+};
+var AgentRouter = class {
+  registry = /* @__PURE__ */ new Map();
+  opts;
+  _urls;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  /** Register an agent class under `name` (URL segment, conversation `agent` value, MCP `ask_<name>`). */
+  register(name, agentClass) {
+    if (!/^[A-Za-z0-9_-]+$/.test(name))
+      throw new ImproperlyConfigured5(`Agent name '${name}' may only contain letters, digits, '_' and '-'.`);
+    if (this.registry.has(name))
+      throw new ImproperlyConfigured5(`An agent named '${name}' is already registered.`);
+    this.registry.set(name, agentClass);
+    this._urls = void 0;
+    return this;
+  }
+  /**
+   * Consume queued runs (`agent.enqueue()`) from the Cloudflare Queue named `queue` (default: every queue).
+   * Call it once, e.g. from an AppConfig's `ready()`. Returns an unregister function.
+   */
+  consumeQueue(queue = "*") {
+    return consumeAgentQueue(queue, (name) => this.create(name));
+  }
+  /** A fresh agent instance for `name`. */
+  create(name) {
+    const cls = this.registry.get(name);
+    if (!cls) throw new ImproperlyConfigured5(`No agent registered as '${name}'.`);
+    const agent = new cls();
+    agent.agentName = name;
+    return agent;
+  }
+  /** Registered agent names. */
+  get names() {
+    return [...this.registry.keys()];
+  }
+  getUrls() {
+    const prefix = this.opts.urlNamePrefix ?? "agents";
+    const out = [];
+    for (const name of this.registry.keys()) {
+      const init = { agentRouter: this, agentName: name };
+      const chat = AgentChatView.asView(init);
+      out.push(
+        path2(`${name}/chat/`, chat, { name: `${prefix}-${name}-chat` }),
+        path2(`${name}/chat`, chat),
+        path2(`${name}/conversations/`, ConversationListView.asView(init), {
+          name: `${prefix}-${name}-conversations`
+        }),
+        path2(`${name}/conversations/<uuid:id>/`, ConversationDetailView.asView(init), {
+          name: `${prefix}-${name}-conversation`
+        })
+      );
+    }
+    return out;
+  }
+  /**
+   * A Streamable HTTP MCP endpoint exposing `tools` plus the registered agents as `ask_<name>` tools
+   * (`agents: false` to leave them out, or a list of names). Mount it with `path('mcp/', agents.mcp())`.
+   */
+  mcp(opts = {}) {
+    return this.mcpServer(opts).urls;
+  }
+  /** The `McpServer` behind `mcp()` (for tests / custom mounting). */
+  mcpServer(opts = {}) {
+    const { agents = true, ...rest } = opts;
+    const names = agents === true ? this.names : agents === false ? [] : agents;
+    const factories = {};
+    for (const name of names) factories[name] = () => this.create(name);
+    return new McpServer({ ...rest, agents: factories });
+  }
+  /** URL patterns to `include()`. */
+  get urls() {
+    this._urls ??= this.getUrls();
+    return this._urls;
+  }
+};
+
+// src/tools/model.ts
+import {
+  FieldFilter,
+  ModelSerializer,
+  ModelViewSet,
+  OrderingFilter,
+  PageNumberPagination,
+  SearchFilter
+} from "@ghuri/rest";
+
+// src/tools/viewset.ts
+import { ImproperlyConfigured as ImproperlyConfigured6 } from "@ghuri/core";
+import { RouterRegistration, SimpleRouter } from "@ghuri/rest";
+var ACTION_ALIASES = {
+  delete: "destroy",
+  partial_update: "partialUpdate",
+  "partial-update": "partialUpdate"
+};
+var STANDARD = /* @__PURE__ */ new Set(["list", "create", "retrieve", "update", "partialUpdate", "destroy"]);
+function viewsetPrefix(viewset) {
+  let model;
+  try {
+    const inst = new viewset();
+    model = inst.queryset?.model ?? viewset.queryset?.model;
+  } catch {
+    model = void 0;
+  }
+  if (model?._meta)
+    return sanitizeToolName(String(model._meta.verboseNamePlural).replace(/\s+/g, "_").toLowerCase());
+  return sanitizeToolName(snakeCase(String(viewset.name).replace(/ViewSet$|View$/, "")));
+}
+var ViewSetTools = class extends Toolkit {
+  entry;
+  opts;
+  prefix;
+  specs;
+  constructor(target, opts = {}) {
+    super();
+    this.opts = opts;
+    if (target instanceof RouterRegistration) {
+      this.entry = target;
+      this.prefix = sanitizeToolName(opts.prefix ?? (target.prefix.replace(/\//g, "_") || target.basename));
+    } else if (typeof target === "function") {
+      this.prefix = sanitizeToolName(opts.prefix ?? viewsetPrefix(target));
+      const router = new SimpleRouter();
+      this.entry = router.register(this.prefix, target, opts.basename ? { basename: opts.basename } : {});
+    } else {
+      throw new TypeError("ViewSetTools expects a viewset class or a router registry entry.");
+    }
+  }
+  /** The (action, tool suffix) pairs to expose. */
+  actionSpecs() {
+    if (this.specs) return this.specs;
+    const available = this.entry.actions;
+    const wanted = this.opts.actions ?? available;
+    this.specs = wanted.map((name) => {
+      const action = ACTION_ALIASES[name] ?? name;
+      if (!available.includes(action)) {
+        throw new ImproperlyConfigured6(
+          `${this.entry.viewset.name} has no routed action '${name}' (available: ${available.join(", ")}).`
+        );
+      }
+      return { action, suffix: snakeCase(name), description: this.opts.descriptions?.[name] };
+    });
+    return this.specs;
+  }
+  getTools() {
+    return this.actionSpecs().map((spec) => this.buildTool(spec));
+  }
+  get model() {
+    return this.entry.model;
+  }
+  modelNames() {
+    const meta = this.model?._meta;
+    return {
+      one: meta ? String(meta.verboseName) : this.entry.basename,
+      many: meta ? String(meta.verboseNamePlural) : this.prefix
+    };
+  }
+  lookup() {
+    const view = this.entry.viewFor("retrieve");
+    const field = view.lookupField ?? "pk";
+    const kwarg = view.lookupUrlKwarg ?? field;
+    const param = kwarg === "pk" ? "id" : kwarg;
+    let schema = { type: ["integer", "string"] };
+    const meta = this.model?._meta;
+    const modelField = meta && (field === "pk" ? meta.pk : meta.getForwardField?.(field));
+    if (modelField && typeof modelField.jsonSchema === "function") {
+      try {
+        const s = modelField.jsonSchema();
+        schema = { type: s.type ?? ["integer", "string"], ...s.format ? { format: s.format } : {} };
+      } catch {
+      }
+    }
+    const { one } = this.modelNames();
+    return { kwarg, param, schema: { ...schema, description: `Identifier (${field}) of the ${one}.` } };
+  }
+  describe(spec, endpoint) {
+    if (spec.description) return spec.description;
+    const { one, many } = this.modelNames();
+    switch (spec.action) {
+      case "list":
+        return `List ${many}. Supports the filters, search, ordering and pagination parameters below; returns the matching ${many}.`;
+      case "retrieve":
+        return `Get one ${one} by id.`;
+      case "create":
+        return `Create a ${one}. Returns the created ${one}.`;
+      case "update":
+        return `Replace a ${one} (all writable fields required). Returns the updated ${one}.`;
+      case "partialUpdate":
+        return `Update some fields of a ${one}; omitted fields are left unchanged. Returns the updated ${one}.`;
+      case "destroy":
+        return `Delete a ${one} by id. This cannot be undone.`;
+    }
+    const extra = this.entry.extraActions.find((a) => a.name === spec.action);
+    const desc = endpoint.description ?? extra?.kwargs.description;
+    if (desc) return desc;
+    return endpoint.detail ? `Run the '${spec.action}' action on one ${one}.` : `Run the '${spec.action}' action on ${many}.`;
+  }
+  buildTool(spec) {
+    const endpoints = this.entry.endpoints.filter((e) => e.action === spec.action);
+    const endpoint = endpoints[0];
+    const methods = [...new Set(endpoints.map((e) => e.method))];
+    const extra = !STANDARD.has(spec.action);
+    const properties = {};
+    const required = [];
+    const lookup = endpoint.detail ? this.lookup() : void 0;
+    if (lookup) {
+      properties[lookup.param] = lookup.schema;
+      required.push(lookup.param);
+    }
+    const hasBodyMethod = methods.some((m) => ["POST", "PUT", "PATCH"].includes(m));
+    let bodyKeys = [];
+    let nestData = false;
+    let queryKeys = [];
+    let freeQuery = false;
+    if (hasBodyMethod) {
+      const kwargs = this.entry.extraActions.find((a) => a.name === spec.action)?.kwargs ?? {};
+      const useSerializer = !extra || kwargs.serializerClass;
+      const schema = useSerializer ? this.entry.jsonSchema(spec.action, { mode: "input", partial: spec.action === "partialUpdate" }) : void 0;
+      if (schema) {
+        const body = cleanInputSchema(schema);
+        const props = body.properties;
+        nestData = !!lookup && lookup.param in props;
+        if (nestData) {
+          properties.data = { ...body, description: "Field values." };
+          if (body.required?.length) required.push("data");
+        } else {
+          Object.assign(properties, props);
+          for (const r of body.required ?? []) required.push(r);
+          bodyKeys = Object.keys(props);
+        }
+      } else {
+        nestData = true;
+        properties.data = {
+          type: "object",
+          description: "Request body (JSON object), if the action takes one."
+        };
+      }
+    }
+    if (spec.action === "list") {
+      const params = this.listParameters();
+      const { properties: qp, required: qr } = parametersToProperties(params);
+      for (const [k, v] of Object.entries(qp)) if (!(k in properties)) properties[k] = v;
+      required.push(...qr.filter((r) => !required.includes(r)));
+      queryKeys = Object.keys(qp);
+    } else if (methods.includes("GET") && extra) {
+      freeQuery = true;
+      properties.query = { type: "object", description: "Optional query string parameters." };
+    }
+    if (methods.length > 1) {
+      properties.method = { type: "string", enum: methods, description: "HTTP method of the action." };
+    }
+    const inputSchema = { type: "object", properties };
+    if (required.length) inputSchema.required = required;
+    const annotations = {
+      title: `${this.prefix} ${spec.suffix}`.replace(/_/g, " "),
+      readOnlyHint: methods.every((m) => m === "GET" || m === "HEAD"),
+      destructiveHint: spec.action === "destroy" || methods.includes("DELETE"),
+      idempotentHint: methods.every((m) => ["GET", "HEAD", "PUT", "DELETE"].includes(m)),
+      openWorldHint: false
+    };
+    const entry = this.entry;
+    return {
+      name: sanitizeToolName(`${this.prefix}_${spec.suffix}`),
+      description: this.describe(spec, endpoint),
+      inputSchema,
+      annotations,
+      parse: (value) => {
+        if (value === void 0 || value === null) return {};
+        if (typeof value !== "object" || Array.isArray(value))
+          throw new ToolError("Arguments must be an object.");
+        const missing = required.filter((r) => value[r] === void 0);
+        if (lookup && missing.includes(lookup.param))
+          throw new ToolError(`Missing required argument '${lookup.param}'.`, { status: 400 });
+        return value;
+      },
+      execute: async (input, ctx) => {
+        const args = { ...input ?? {} };
+        const kwargs = {};
+        if (lookup) {
+          kwargs[lookup.kwarg] = args[lookup.param];
+          delete args[lookup.param];
+        }
+        const method = typeof args.method === "string" ? args.method.toUpperCase() : void 0;
+        delete args.method;
+        let query;
+        let data;
+        if (spec.action === "list") {
+          query = {};
+          for (const k of queryKeys) if (args[k] !== void 0 && args[k] !== null) query[k] = args[k];
+        } else if (freeQuery && args.query && typeof args.query === "object") {
+          query = args.query;
+          delete args.query;
+        }
+        if (hasBodyMethod && method !== "GET") {
+          if (nestData) data = args.data ?? {};
+          else {
+            data = {};
+            for (const k of bodyKeys) if (k in args) data[k] = args[k];
+          }
+        }
+        const user = ctx.user?.isAuthenticated ? ctx.user : null;
+        const res = await entry.invoke(spec.action, { user, kwargs, query, data, method });
+        return toolResult(res.status, res.data);
+      }
+    };
+  }
+  /** OpenAPI query parameters of the list action (filter backends + paginator). */
+  listParameters() {
+    const view = this.entry.viewFor("list");
+    const out = [];
+    const backends = typeof view.getFilterBackends === "function" ? view.getFilterBackends() : view.filterBackends ?? [];
+    for (const B of backends) {
+      const b = new B();
+      if (typeof b.getSchemaOperationParameters === "function")
+        out.push(...b.getSchemaOperationParameters(view));
+    }
+    const paginator = view.paginator;
+    if (paginator && typeof paginator.getSchemaOperationParameters === "function")
+      out.push(...paginator.getSchemaOperationParameters(view));
+    const seen = /* @__PURE__ */ new Set();
+    return out.filter((p) => {
+      const name = String(p.name);
+      if (seen.has(name)) return false;
+      seen.add(name);
+      return true;
+    });
+  }
+};
+function toolResult(status, data) {
+  if (status >= 400) throw new ToolError(errorMessage(status, data), { status, detail: data });
+  if (status === 204 || data === null || data === "") return { success: true, status };
+  return data;
+}
+function errorMessage(status, data) {
+  const detail = data && typeof data === "object" && typeof data.detail === "string" ? data.detail : typeof data === "string" && data ? data : status === 400 ? `Validation failed: ${JSON.stringify(data)}` : void 0;
+  return `${detail ?? "Request failed."} (HTTP ${status})`;
+}
+
+// src/tools/model.ts
+var ACTIONS = {
+  list: "list",
+  retrieve: "retrieve",
+  create: "create",
+  update: "partialUpdate",
+  delete: "destroy"
+};
+function defaultSerializer(model) {
+  const cls = class extends ModelSerializer {
+    static Meta = { model, fields: "__all__" };
+  };
+  Object.defineProperty(cls, "name", { value: `${model._meta.objectName}Serializer` });
+  return cls;
+}
+function buildViewSet(model, opts) {
+  const serializer = opts.serializer ?? defaultSerializer(model);
+  const backends = [];
+  if (opts.filterFields) backends.push(FieldFilter);
+  if (opts.searchFields?.length) backends.push(SearchFilter);
+  if (opts.orderingFields || opts.ordering) backends.push(OrderingFilter);
+  const pageSize = opts.pageSize ?? 20;
+  const maxPageSize = opts.maxPageSize ?? Math.max(100, pageSize);
+  const Paginator = class AgentPagination extends PageNumberPagination {
+    pageSize = pageSize;
+    pageSizeQueryParam = "pageSize";
+    maxPageSize = maxPageSize;
+  };
+  const ViewSet = class extends ModelViewSet {
+    queryset = model;
+    serializerClass = serializer;
+    filterBackends = backends;
+    paginationClass = Paginator;
+    searchFields = opts.searchFields;
+    orderingFields = opts.orderingFields;
+    ordering = opts.ordering;
+    filtersetFields = opts.filterFields;
+    constructor() {
+      super();
+      if (opts.permissionClasses) this.permissionClasses = opts.permissionClasses;
+    }
+    getQueryset() {
+      const qs = super.getQueryset();
+      return opts.filter ? opts.filter(qs, this.request.user) : qs;
+    }
+    async performCreate(serializer2) {
+      await serializer2.save(opts.saveKwargs ? await opts.saveKwargs(this.request.user, "create") : {});
+    }
+    async performUpdate(serializer2) {
+      await serializer2.save(opts.saveKwargs ? await opts.saveKwargs(this.request.user, "update") : {});
+    }
+  };
+  Object.defineProperty(ViewSet, "name", { value: `${model._meta.objectName}ToolsViewSet` });
+  return ViewSet;
+}
+var ModelTools = class extends ViewSetTools {
+  modelClass;
+  modelOptions;
+  constructor(model, opts = {}) {
+    if (!model?._meta) throw new TypeError("ModelTools expects a model class.");
+    const prefix = opts.prefix ?? sanitizeToolName(String(model._meta.verboseNamePlural).replace(/\s+/g, "_").toLowerCase());
+    super(buildViewSet(model, opts), { prefix, basename: model._meta.modelName });
+    this.modelClass = model;
+    this.modelOptions = opts;
+  }
+  actionSpecs() {
+    if (!this.specs) {
+      const actions = this.modelOptions.actions ?? ["list", "retrieve"];
+      this.specs = actions.map((a) => {
+        const action = ACTIONS[a];
+        if (!action)
+          throw new TypeError(`ModelTools: unknown action '${a}' (use ${Object.keys(ACTIONS).join(", ")}).`);
+        return { action, suffix: a, description: this.modelOptions.descriptions?.[a] };
+      });
+    }
+    return this.specs;
+  }
+};
+
+// src/tools/router.ts
+function matches(entry, spec) {
+  if (typeof spec === "function") return spec(entry);
+  return spec.includes(entry.prefix) || spec.includes(entry.basename);
+}
+var RouterTools = class extends Toolkit {
+  constructor(router, opts = {}) {
+    super();
+    this.router = router;
+    this.opts = opts;
+  }
+  router;
+  opts;
+  /** The `ViewSetTools` of each included registration. */
+  toolkits() {
+    const out = [];
+    for (const entry of this.router.registry) {
+      if (this.opts.include && !matches(entry, this.opts.include)) continue;
+      if (this.opts.exclude && matches(entry, this.opts.exclude)) continue;
+      let actions = this.opts.actions?.[entry.prefix] ?? this.opts.actions?.[entry.basename];
+      if (this.opts.readOnly) {
+        const safe = new Set(entry.endpoints.filter((e) => e.method === "GET").map((e) => e.action));
+        actions = (actions ?? entry.actions).filter((a) => safe.has(a));
+      }
+      if (actions && !actions.length) continue;
+      out.push(new ViewSetTools(entry, actions ? { actions } : {}));
+    }
+    return out;
+  }
+  getTools() {
+    const excluded = Array.isArray(this.opts.exclude) ? new Set(this.opts.exclude) : void 0;
+    return this.toolkits().flatMap((t) => t.getTools()).filter((t) => !excluded?.has(t.name));
+  }
+};
+export {
+  AGENT_JOB_TYPE,
+  Agent,
+  AgentChatView,
+  AgentError,
+  AgentRouter,
+  AgentStream,
+  AgentsConfig,
+  Conversation,
+  ConversationDetailView,
+  ConversationListView,
+  ConversationNotFound,
+  JSONRPC,
+  MCP_LATEST_PROTOCOL_VERSION,
+  MCP_PROTOCOL_VERSIONS,
+  MESSAGE_ROLES,
+  McpError,
+  McpServer,
+  McpView,
+  Message,
+  ModelResolutionError,
+  ModelTools,
+  ModelUnavailable,
+  RouterTools,
+  TOOL,
+  TOOL_OPTIONS,
+  ToolError,
+  ToolInputError,
+  Toolkit,
+  UnknownToolError,
+  ViewSetTools,
+  agentAuthenticationClasses,
+  agentTool,
+  agentsSettings,
+  collectDeclaredTools,
+  consumeAgentQueue,
+  createConversation,
+  defineTool,
+  enqueueRun,
+  getConversation,
+  getProviders,
+  isAgentTool,
+  isLanguageModel,
+  isToolDecorator,
+  isToolkit,
+  loadJobUser,
+  loadMessages,
+  memoryAvailable,
+  registerProvider,
+  resolveModel,
+  runTool,
+  sanitizeToolName,
+  saveMessages,
+  standaloneTool,
+  toJSONSchema,
+  toToolError,
+  tool,
+  unregisterProvider
+};
+//# sourceMappingURL=index.js.map