@anchrd/colab-sdk 0.1.21 → 0.1.23

package/dist/goals/goals.js

@@ -0,0 +1,329 @@
+import { z } from "zod";
+import { idSchema } from "../ids/ids.js";
+import { Limit } from "../list-input.js";
+import { Message } from "../messages/messages.js";
+import { Missing } from "../missing/missing.js";
+import { NodeId, NodeKind, NodePath, NodePerson } from "../nodes/nodes.js";
+import { IdempotencyKey, Rev } from "../primitives/primitives.js";
+import { Schedule } from "../schedule/schedule.js";
+import { UserId } from "../users/users.js";
+// Goals (#813, Nodes › Ziel, E139): the inputs of `intelligence_goal_create|get|update` and
+// `intelligence_goal_run_create|list|get|update|complete|cancel`, and their answers. A goal says
+// what is to be reached by when; its Operator makes the plan itself in every run. Fields stand above
+// the line like on a card, the goal itself below it in Markdown. A run is an object of its own at the
+// goal, frozen once it ends.
+export const GoalId = NodeId.describe("The goal's id, a `node_…` of kind goal.");
+// A run of a goal is the resource `run` (`run_…`) like a run of a process board; defined here, not
+// imported from `runs.ts`, which `versions.ts` reaches through this file.
+const RunId = idSchema("run").describe("The run's id, `run_…`, as intelligence_goal_run_list names it.");
+export const goalPlannings = ["short", "detailed"];
+export const GoalPlanning = z
+    .enum(goalPlannings)
+    .describe("How the Operator writes its plan: short (one line per step) or detailed (every step with how and the result it leaves).");
+const Content = z
+    .string()
+    .max(200_000)
+    .describe("The goal as Markdown, like you would tell a colleague: goal, order, quality, done when. Link the boards, skills, tables and folders it uses as `[Name](/n/node_…)`; Startklar checks that the Operator reaches each of them.");
+// US dollars per run, in cents of precision.
+const Budget = z
+    .number()
+    .positive()
+    .max(100_000)
+    .multipleOf(0.01)
+    .describe("The budget of one run in US dollars; a run that spends it ends as missed.");
+const MaxHours = z
+    .int()
+    .min(1)
+    .max(24 * 90)
+    .describe("How long one run may take at most, in hours; a run past it ends as missed.");
+const Rhythm = Schedule.describe("When a run starts, on the rhythm's clock: daily, weekly, monthly or on dates, like a process board's schedule; whileOpen does not apply, because a moment that falls due while a run is open is always skipped. manual or null starts runs only by hand.");
+// The fields above the line. Every one optional on a change: only what is sent changes.
+const GoalFieldsInput = {
+    operatorId: UserId.nullable()
+        .optional()
+        .describe("The Operator that works on the goal, a machine that can read it; null for none."),
+    rhythm: Rhythm.nullable().optional(),
+    budget: Budget.nullable().optional(),
+    maxHours: MaxHours.nullable().optional(),
+    planning: GoalPlanning.optional(),
+    reportToId: UserId.nullable()
+        .optional()
+        .describe("Who gets the report of every run, someone who can read the goal; null for nobody."),
+};
+export const GoalCreateInput = z.strictObject({
+    // ⚠️ Required and nullable (trap C015): null is the top level of Shared.
+    parentId: NodeId.nullable().describe("The folder to create the goal in, one you can write to; null creates it on the top level of Shared."),
+    name: z.string().max(200).describe("The name as people read it, like `Monatsbericht`."),
+    content: Content,
+    ...GoalFieldsInput,
+    idempotencyKey: IdempotencyKey,
+});
+export const GoalGetInput = z.strictObject({ goalId: GoalId });
+export const GoalUpdateInput = z.strictObject({
+    goalId: GoalId,
+    content: Content.optional(),
+    ...GoalFieldsInput,
+    rev: Rev,
+    editSession: z
+        .string()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("The editing session the editor keeps while a person stays on the goal: saves of one session go into one version. Leaving it out makes every save a version of its own, which is right for an AI."),
+});
+// What Startklar checks, without a model (E139): each node the goal links with the right the
+// Operator needs there, the Operator itself, and the frame (budget and longest duration).
+export const GoalCheck = z.object({
+    // reference: a node the text links; operator: the Operator of the goal; helper: an Operator the text
+    // mentions (`/u/user_…`), who gets cards on the boards it links (#829); connector: a connector
+    // whose tool the text names (`github_issue_list`, #829); frame: budget and longest duration.
+    kind: z.enum(["reference", "operator", "helper", "connector", "frame"]),
+    nodeId: NodeId.nullable(),
+    // The node's name and kind as the caller may read them; null where they may not, or it is gone.
+    name: z.string().nullable(),
+    nodeKind: NodeKind.nullable(),
+    // The right the Operator needs on the node: write on a board, where it hands over work as cards,
+    // read on everything else.
+    needs: z.enum(["read", "write"]).nullable(),
+    ok: z.boolean(),
+    // Why it is red, a sentence for people and their AI; null when it is green.
+    problem: z.string().nullable(),
+    // A missing right with who can give it (E126), null otherwise.
+    missing: Missing.nullable(),
+    // The Operator a helper check is about, with its name as the caller may read it; null elsewhere.
+    // nodeId, name and nodeKind then name the board it needs write on, null when the text links none.
+    user: z.object({ userId: z.string(), name: z.string().nullable() }).nullable(),
+    // The connector a connector check is about, with the tools of it the text names; null elsewhere.
+    connector: z
+        .object({ connectorId: z.string(), name: z.string(), tools: z.array(z.string()) })
+        .nullable(),
+});
+export const GoalReady = z.object({
+    // Green: nothing is red, Play may start a run.
+    ok: z.boolean(),
+    checkedAt: z.iso.datetime(),
+    checks: z.array(GoalCheck),
+    // What the Operator's short question about the goal costs, about: the cheapest session of the
+    // goal's last runs; null without one (#829). Asking blocks nothing.
+    questionCostUsd: z.number().nullable(),
+});
+export const goalRunStatuses = ["running", "reached", "missed", "ended"];
+export const GoalRunStatus = z
+    .enum(goalRunStatuses)
+    .describe("running (started, not over), reached (the Operator closed it with its report), missed (the longest duration or the budget ran out, or the Operator says it was not reached), ended (a person stopped it).");
+export const GoalRunTrigger = z
+    .enum(["rhythm", "play"])
+    .describe("What started the run: the rhythm, or Play by a person or their AI.");
+const Line = z.string().min(1).max(500);
+const Paragraph = z.string().max(4000);
+export const GoalPlanStep = z.object({
+    title: Line,
+    how: Paragraph.nullable(),
+    result: Paragraph.nullable(),
+    done: z.boolean(),
+    // The card this step was handed over as, on a normal board; null when the Operator does it itself.
+    taskId: NodeId.nullable(),
+});
+const GoalPlanStepInput = z.strictObject({
+    title: Line.describe("The step in a few words."),
+    how: Paragraph.nullable()
+        .optional()
+        .describe("How it is done, and by whom: yourself, or a card for someone else."),
+    result: Paragraph.nullable().optional().describe("What the step left, once it is done."),
+    done: z.boolean().optional().describe("Whether the step is done; leaving it out means not yet."),
+    taskId: NodeId.nullable()
+        .optional()
+        .describe("The card the step was handed over as, on a normal board."),
+});
+export const GoalFollowUp = z.object({
+    at: z.iso.datetime(),
+    text: z.string(),
+    by: NodePerson,
+});
+// One time the Operator was woken for the run: by the rhythm or Play that started it, a mention in
+// the goal's chat, or its follow-up.
+export const GoalSession = z.object({
+    number: z.int(),
+    trigger: z.enum(["rhythm", "play", "mention", "followup"]),
+    at: z.iso.datetime(),
+    // Who mentioned the Operator, or started the run; null for the rhythm and the follow-up.
+    by: NodePerson.nullable(),
+    summary: z.string().nullable(),
+    // US dollars this session cost, as the Operator's run reported it; null while unknown.
+    costUsd: z.number().nullable(),
+});
+const ReportText = z.string().max(20_000);
+const reportParts = {
+    result: ReportText.min(1).describe("What came out, in a few sentences: the line of the run."),
+    changed: ReportText.nullable().optional().describe("What changed, with links to the nodes."),
+    open: ReportText.nullable()
+        .optional()
+        .describe("What stays open, including cards handed over that are not done."),
+    learned: ReportText.nullable()
+        .optional()
+        .describe("What the next run should know: it is the goal's memory."),
+    participants: ReportText.nullable()
+        .optional()
+        .describe("Who worked on it, people and Operators."),
+    frame: ReportText.nullable().optional().describe("Time and money spent against the frame."),
+};
+export const GoalReport = z.object({
+    result: z.string(),
+    changed: z.string().nullable(),
+    open: z.string().nullable(),
+    learned: z.string().nullable(),
+    participants: z.string().nullable(),
+    frame: z.string().nullable(),
+});
+export const GoalRunItem = z.object({
+    runId: RunId,
+    goalId: GoalId,
+    status: GoalRunStatus,
+    trigger: GoalRunTrigger,
+    // The rhythm's moment the run stands for, null for Play.
+    dueAt: z.iso.datetime().nullable(),
+    startedAt: z.iso.datetime(),
+    startedBy: NodePerson.nullable(),
+    // When the longest duration runs out, null without one.
+    endsAt: z.iso.datetime().nullable(),
+    completedAt: z.iso.datetime().nullable(),
+    completedBy: NodePerson.nullable(),
+    // The number of the goal's version the run worked with.
+    goalVersion: z.int(),
+    steps: z.object({ done: z.int(), total: z.int() }),
+    sessions: z.int(),
+    spentUsd: z.number(),
+    budgetUsd: z.number().nullable(),
+    // The line of the run: the report's result, else the current state.
+    summary: z.string().nullable(),
+    // Moments of the rhythm that fell due while this run was open, skipped and never made up.
+    skipped: z.array(z.iso.datetime()),
+});
+// The fields above the line as a version of the goal holds them.
+export const GoalFields = z.object({
+    operatorId: z.string().nullable(),
+    rhythm: Schedule.nullable(),
+    budget: z.number().nullable(),
+    maxHours: z.int().nullable(),
+    planning: GoalPlanning,
+    reportToId: z.string().nullable(),
+});
+export const GoalRunDetail = GoalRunItem.extend({
+    plan: z.array(GoalPlanStep),
+    // The Operator's state of the run, rewritten at the end of every session.
+    state: z.string().nullable(),
+    followUp: GoalFollowUp.nullable(),
+    sessionList: z.array(GoalSession),
+    report: GoalReport.nullable(),
+    // The goal as the run worked with it: the fields and the text of its version.
+    fields: GoalFields,
+    // The Operator and who got the report in that version, with their names today.
+    operator: NodePerson.nullable(),
+    reportTo: NodePerson.nullable(),
+    content: z.string(),
+    // The chat of the goal while the run was open, oldest first; only once the run is over.
+    chat: z.array(Message).nullable(),
+    rev: z.int(),
+    rights: z.object({
+        // Plan, state and follow-up: the goal's Operator and whoever writes on the goal.
+        update: z.boolean(),
+        // Closing with a report: the goal's Operator, while the run is open or ended without a report.
+        complete: z.boolean(),
+        // Stopping: whoever writes on the goal.
+        cancel: z.boolean(),
+    }),
+});
+export const GoalDetail = z.object({
+    goalId: GoalId,
+    name: z.string(),
+    hidden: z.boolean(),
+    parentId: NodeId.nullable(),
+    path: NodePath,
+    content: z.string(),
+    operator: NodePerson.nullable(),
+    rhythm: Schedule.nullable(),
+    // The next moment of the rhythm, null without one.
+    nextRunAt: z.iso.datetime().nullable(),
+    budget: z.number().nullable(),
+    maxHours: z.int().nullable(),
+    planning: GoalPlanning,
+    reportTo: NodePerson.nullable(),
+    ready: GoalReady,
+    // The run that is open now, with its plan and follow-up; null without one.
+    run: GoalRunDetail.nullable(),
+    // The current version's number ("Version 5").
+    version: z.int(),
+    rev: z.int(),
+    archivedAt: z.iso.datetime().nullable(),
+    rights: z.object({
+        write: z.boolean(),
+        // Play: write, no open run and Startklar green.
+        start: z.boolean(),
+    }),
+});
+export const GoalRunCreateInput = z.strictObject({
+    goalId: GoalId.describe("The goal to start a run of (Play), one you can write to. Refused with conflict while a run is open or Startklar is red."),
+    idempotencyKey: IdempotencyKey,
+});
+export const GoalRunListInput = z.strictObject({
+    goalId: GoalId,
+    status: GoalRunStatus.optional().describe("Only the runs in this state."),
+    cursor: z
+        .string()
+        .max(1000)
+        .optional()
+        .describe("The nextCursor of the previous page, unchanged. Leaving it out starts at the newest."),
+    limit: Limit.optional().describe("How many runs one page holds, 1 to 100. Leaving it out gives 50."),
+});
+export const GoalRunList = z.object({
+    items: z.array(GoalRunItem),
+    nextCursor: z.string().nullable(),
+});
+export const GoalRunGetInput = z.strictObject({ goalId: GoalId, runId: RunId });
+export const GoalRunUpdateInput = z.strictObject({
+    goalId: GoalId,
+    runId: RunId,
+    plan: z
+        .array(GoalPlanStepInput)
+        .max(50)
+        .optional()
+        .describe("The whole plan, in order; it replaces the one before."),
+    state: z
+        .string()
+        .max(4000)
+        .nullable()
+        .optional()
+        .describe("Where the run stands now, rewritten at the end of every session."),
+    followUp: z
+        .strictObject({
+        at: z.iso
+            .datetime({ offset: true })
+            .describe("When Colab mentions the Operator in the goal's chat again, ISO 8601: in the future and before the run's longest duration runs out."),
+        text: z.string().min(1).max(2000).describe("What to check then, in a sentence."),
+    })
+        .nullable()
+        .optional()
+        .describe("The one follow-up of the run: set or move it, or null to delete it. At most one is open."),
+    note: z
+        .string()
+        .max(500)
+        .optional()
+        .describe("What this session did, in one line: shown beside the session in the plan."),
+    rev: Rev.describe("The run's revision as the last read of it returned it."),
+});
+export const GoalRunCompleteInput = z.strictObject({
+    goalId: GoalId,
+    runId: RunId,
+    status: z
+        .enum(["reached", "missed"])
+        .describe("reached when every point of done-when holds, missed otherwise. Ignored for a run that is already over (Colab or a person ended it): then only the report is added."),
+    report: z.strictObject(reportParts).describe("The report of the run, sent to Report to."),
+});
+export const GoalRunCancelInput = z.strictObject({
+    goalId: GoalId,
+    runId: RunId,
+    report: z
+        .boolean()
+        .optional()
+        .describe("true asks the Operator in the goal's chat for a short report; leaving it out ends the run without one."),
+});

package/dist/grammar/grammar.d.ts

@@ -8,6 +8,8 @@ export declare const resources: {
     readonly task: "tasks";
     readonly gadget: "gadgets";
     readonly file: "files";
+    readonly goal: "goals";
+    readonly skill: "skills";
     readonly run: "runs";
     readonly version: "versions";
     readonly chat: "chats";
@@ -34,6 +36,7 @@ export declare const resources: {
     readonly secret: "secrets";
     readonly step: "steps";
     readonly crawl: "crawls";
+    readonly mcp: "mcps";
 };
 export declare const actions: readonly ["list", "get", "create", "update", "archive", "restore", "purge"];
 export declare const verbs: readonly ["invite", "resend", "disable", "enable", "rotate", "share", "move", "start", "complete", "test", "revoke", "remove", "unlock", "publish", "schedule", "unpublish", "cancel"];

package/dist/grammar/grammar.js

@@ -24,6 +24,12 @@ export const resources = {
     // A small application an AI builds and Colab runs (#642, E118): `intelligence_gadget_*`.
     gadget: "gadgets",
     file: "files",
+    // What is to be reached by when, with its runs (#813, E139, Nodes › Ziel): `intelligence_goal_*`,
+    // a run of it `intelligence_goal_run_*`. Named by the documentation page.
+    goal: "goals",
+    // How something is done well, with its result, trigger and tests (#817, #807, E140, Nodes › Skill):
+    // `intelligence_skill_*`, a run of it in its log `intelligence_skill_run_*`.
+    skill: "skills",
     run: "runs",
     version: "versions",
     chat: "chats",
@@ -63,6 +69,9 @@ export const resources = {
     // A crawl of a known website at Cloudflare Browser Rendering (#785, E137): `intelligence_crawl_*`.
     // Its pages are searched in Colab for 14 days and stored nowhere as a node.
     crawl: "crawls",
+    // A person's own MCP server for their personal Operators (#802, E144, Einstellungen › MCPs):
+    // `operator_mcp_*`, its protocol `operator_mcp_call_list`. Named by the ticket and the page.
+    mcp: "mcps",
 };
 // The closed list of actions with a route of their own shape.
 export const actions = ["list", "get", "create", "update", "archive", "restore", "purge"];
@@ -220,6 +229,9 @@ const routeExceptions = {
         method: "PATCH",
         path: "/api/intelligence/boards/:boardId/tasks",
     },
+    // The limits of personal Operators (E143, #804): without `userId` the company's defaults, with it
+    // one person's own values. The defaults are no person, so there is no one `userId` for the path.
+    operator_user_update: { method: "PATCH", path: "/api/operator/users" },
 };
 // `access_user_invite` → `POST /api/access/users/:userId/invite`.
 export function toolRoute(name) {

package/dist/mcps/mcps.d.ts

@@ -0,0 +1,264 @@
+import { z } from "zod";
+export declare const McpId: z.ZodTemplateLiteral<`mcp_${string}`>;
+export type McpId = z.infer<typeof McpId>;
+export declare const McpAuth: z.ZodEnum<{
+    oauth: "oauth";
+    bearer: "bearer";
+    header: "header";
+    none: "none";
+}>;
+export type McpAuth = z.infer<typeof McpAuth>;
+export declare const McpState: z.ZodEnum<{
+    expired: "expired";
+    running: "running";
+    unreachable: "unreachable";
+    pending: "pending";
+}>;
+export type McpState = z.infer<typeof McpState>;
+export declare const mcpCatalog: readonly [{
+    readonly id: "gmail";
+    readonly name: "Gmail";
+    readonly url: "https://gmailmcp.googleapis.com/mcp/v1";
+    readonly auth: "oauth";
+    readonly signIn: "Google";
+    readonly color: "#c5221f";
+    readonly initials: "G";
+}, {
+    readonly id: "calendar";
+    readonly name: "Google Calendar";
+    readonly url: "https://calendarmcp.googleapis.com/mcp/v1";
+    readonly auth: "oauth";
+    readonly signIn: "Google";
+    readonly color: "#1a73e8";
+    readonly initials: "K";
+}, {
+    readonly id: "drive";
+    readonly name: "Google Drive";
+    readonly url: "https://drivemcp.googleapis.com/mcp/v1";
+    readonly auth: "oauth";
+    readonly signIn: "Google";
+    readonly color: "#188038";
+    readonly initials: "D";
+}, {
+    readonly id: "slack";
+    readonly name: "Slack";
+    readonly url: "https://mcp.slack.com/mcp";
+    readonly auth: "oauth";
+    readonly signIn: "Slack";
+    readonly color: "#4a154b";
+    readonly initials: "Sl";
+}, {
+    readonly id: "teams";
+    readonly name: "Microsoft Teams";
+    readonly url: "https://agent365.svc.cloud.microsoft/agents/servers/mcp_TeamsServer";
+    readonly auth: "oauth";
+    readonly signIn: "Microsoft";
+    readonly color: "#5059c9";
+    readonly initials: "T";
+}, {
+    readonly id: "outlook";
+    readonly name: "Outlook";
+    readonly url: "https://agent365.svc.cloud.microsoft/agents/servers/mcp_MailTools";
+    readonly auth: "oauth";
+    readonly signIn: "Microsoft";
+    readonly color: "#0f6cbd";
+    readonly initials: "O";
+}, {
+    readonly id: "hubspot";
+    readonly name: "HubSpot";
+    readonly url: "https://mcp.hubspot.com";
+    readonly auth: "oauth";
+    readonly signIn: "HubSpot";
+    readonly color: "#c2410c";
+    readonly initials: "H";
+}, {
+    readonly id: "notion";
+    readonly name: "Notion";
+    readonly url: "https://mcp.notion.com/mcp";
+    readonly auth: "oauth";
+    readonly signIn: "Notion";
+    readonly color: "#111111";
+    readonly initials: "N";
+}];
+export type McpCatalogEntry = (typeof mcpCatalog)[number];
+export declare const McpCatalogId: z.ZodEnum<{
+    [x: string]: string;
+}>;
+export type McpCatalogId = McpCatalogEntry["id"];
+export declare const McpListInput: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodTemplateLiteral<`mcp_${string}`>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type McpListInput = z.infer<typeof McpListInput>;
+export declare const McpGetInput: z.ZodObject<{
+    mcpId: z.ZodTemplateLiteral<`mcp_${string}`>;
+}, z.core.$strict>;
+export type McpGetInput = z.infer<typeof McpGetInput>;
+export declare const McpCreateInput: z.ZodObject<{
+    catalogId: z.ZodOptional<z.ZodEnum<{
+        [x: string]: string;
+    }>>;
+    name: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodURL>;
+    auth: z.ZodOptional<z.ZodEnum<{
+        oauth: "oauth";
+        bearer: "bearer";
+        header: "header";
+        none: "none";
+    }>>;
+    headerName: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type McpCreateInput = z.infer<typeof McpCreateInput>;
+export declare const McpUpdateInput: z.ZodObject<{
+    mcpId: z.ZodTemplateLiteral<`mcp_${string}`>;
+    name: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    value: z.ZodOptional<z.ZodString>;
+    signIn: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>;
+export type McpUpdateInput = z.infer<typeof McpUpdateInput>;
+export declare const McpTestInput: z.ZodObject<{
+    mcpId: z.ZodTemplateLiteral<`mcp_${string}`>;
+}, z.core.$strict>;
+export type McpTestInput = z.infer<typeof McpTestInput>;
+export declare const McpRevokeInput: z.ZodObject<{
+    mcpId: z.ZodTemplateLiteral<`mcp_${string}`>;
+}, z.core.$strict>;
+export type McpRevokeInput = z.infer<typeof McpRevokeInput>;
+export declare const McpCallListInput: z.ZodObject<{
+    mcpId: z.ZodTemplateLiteral<`mcp_${string}`>;
+    cursor: z.ZodOptional<z.ZodTemplateLiteral<`call_${string}`>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type McpCallListInput = z.infer<typeof McpCallListInput>;
+export declare const McpTool: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    writes: z.ZodBoolean;
+    enabled: z.ZodBoolean;
+}, z.core.$strip>;
+export type McpTool = z.infer<typeof McpTool>;
+export declare const Mcp: z.ZodObject<{
+    mcpId: z.ZodTemplateLiteral<`mcp_${string}`>;
+    catalogId: z.ZodNullable<z.ZodEnum<{
+        [x: string]: string;
+    }>>;
+    name: z.ZodString;
+    url: z.ZodString;
+    auth: z.ZodEnum<{
+        oauth: "oauth";
+        bearer: "bearer";
+        header: "header";
+        none: "none";
+    }>;
+    headerName: z.ZodNullable<z.ZodString>;
+    state: z.ZodEnum<{
+        expired: "expired";
+        running: "running";
+        unreachable: "unreachable";
+        pending: "pending";
+    }>;
+    authorizeUrl: z.ZodNullable<z.ZodString>;
+    problem: z.ZodNullable<z.ZodString>;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        writes: z.ZodBoolean;
+        enabled: z.ZodBoolean;
+    }, z.core.$strip>>;
+    machineIds: z.ZodArray<z.ZodTemplateLiteral<`user_${string}`>>;
+    checkedAt: z.ZodNullable<z.ZodISODateTime>;
+    createdAt: z.ZodISODateTime;
+    createdBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type Mcp = z.infer<typeof Mcp>;
+export declare const McpList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        mcpId: z.ZodTemplateLiteral<`mcp_${string}`>;
+        catalogId: z.ZodNullable<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+        name: z.ZodString;
+        url: z.ZodString;
+        auth: z.ZodEnum<{
+            oauth: "oauth";
+            bearer: "bearer";
+            header: "header";
+            none: "none";
+        }>;
+        headerName: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            expired: "expired";
+            running: "running";
+            unreachable: "unreachable";
+            pending: "pending";
+        }>;
+        authorizeUrl: z.ZodNullable<z.ZodString>;
+        problem: z.ZodNullable<z.ZodString>;
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            writes: z.ZodBoolean;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>>;
+        machineIds: z.ZodArray<z.ZodTemplateLiteral<`user_${string}`>>;
+        checkedAt: z.ZodNullable<z.ZodISODateTime>;
+        createdAt: z.ZodISODateTime;
+        createdBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`mcp_${string}`>>;
+}, z.core.$strip>;
+export type McpList = z.infer<typeof McpList>;
+export declare const McpCallAction: z.ZodEnum<{
+    blocked: "blocked";
+    update: "update";
+    test: "test";
+    revoke: "revoke";
+    call: "call";
+    connect: "connect";
+    signin: "signin";
+    expire: "expire";
+}>;
+export type McpCallAction = z.infer<typeof McpCallAction>;
+export declare const McpCall: z.ZodObject<{
+    callId: z.ZodTemplateLiteral<`call_${string}`>;
+    action: z.ZodEnum<{
+        blocked: "blocked";
+        update: "update";
+        test: "test";
+        revoke: "revoke";
+        call: "call";
+        connect: "connect";
+        signin: "signin";
+        expire: "expire";
+    }>;
+    tool: z.ZodNullable<z.ZodString>;
+    machineId: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+    status: z.ZodNullable<z.ZodInt>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type McpCall = z.infer<typeof McpCall>;
+export declare const McpCallList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        callId: z.ZodTemplateLiteral<`call_${string}`>;
+        action: z.ZodEnum<{
+            blocked: "blocked";
+            update: "update";
+            test: "test";
+            revoke: "revoke";
+            call: "call";
+            connect: "connect";
+            signin: "signin";
+            expire: "expire";
+        }>;
+        tool: z.ZodNullable<z.ZodString>;
+        machineId: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+        status: z.ZodNullable<z.ZodInt>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`call_${string}`>>;
+}, z.core.$strip>;
+export type McpCallList = z.infer<typeof McpCallList>;