@anchrd/colab-sdk 0.1.7 → 0.1.8

package/dist/functions/functions.d.ts

@@ -22,5 +22,5 @@ export declare const FunctionRemoved: z.ZodObject<{
     functionId: z.ZodTemplateLiteral<`function_${string}`>;
     name: z.ZodString;
     permissions: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type FunctionRemoved = z.infer<typeof FunctionRemoved>;

package/dist/functions/functions.js

@@ -21,7 +21,7 @@ export const ServiceInterfaceFunctionRemoveInput = z.strictObject({
     functionId: FunctionId,
 });
 // What fell with a removed function: the rights the roles held on it.
-export const FunctionRemoved = z.strictObject({
+export const FunctionRemoved = z.object({
     functionId: FunctionId,
     name: z.string(),
     permissions: z.array(z.string()),

package/dist/grammar/grammar.d.ts

@@ -32,6 +32,7 @@ export declare const resources: {
     readonly credential: "credentials";
     readonly sso: "sso";
     readonly secret: "secrets";
+    readonly step: "steps";
 };
 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

@@ -56,6 +56,9 @@ export const resources = {
     // password, `_get` shows it to an admin in admin mode, `_remove` makes the node public again. One
     // per node, with an id of its own like every sub-resource (`secret_…`).
     secret: "secrets",
+    // One step of an Operator run as its CLI's output showed it (E112), a sub-resource of the run:
+    // `operator_run_step_list`. Not `event`, the protocol's resource, and not `message`, a chat's.
+    step: "steps",
 };
 // The closed list of actions with a route of their own shape.
 export const actions = ["list", "get", "create", "update", "archive", "restore", "purge"];
@@ -86,7 +89,8 @@ export const verbs = [
     "unpublish",
     // A connector's run at the provider is ended before it completes (#567, E108):
     // `fal_request_cancel`. Not `revoke`, which ends an access in Colab, and not `archive`: nothing
-    // stays to restore, and a cancelled run may still be billed.
+    // stays to restore, and a cancelled run may still be billed. An Operator run stopped by hand is
+    // the same (E112): `operator_run_cancel`.
     "cancel",
 ];
 export function isPackage(word) {

package/dist/grants/grants.d.ts

@@ -31,8 +31,8 @@ export declare const NodeGrant: z.ZodObject<{
     inheritedFrom: z.ZodNullable<z.ZodObject<{
         nodeId: z.ZodTemplateLiteral<`node_${string}`>;
         name: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type NodeGrant = z.infer<typeof NodeGrant>;
 export declare const NodeGrantList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
@@ -53,10 +53,10 @@ export declare const NodeGrantList: z.ZodObject<{
         inheritedFrom: z.ZodNullable<z.ZodObject<{
             nodeId: z.ZodTemplateLiteral<`node_${string}`>;
             name: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type NodeGrantList = z.infer<typeof NodeGrantList>;
 export declare const NodeShareInput: z.ZodObject<{
     nodeId: z.ZodTemplateLiteral<`node_${string}`>;
@@ -78,7 +78,7 @@ export declare const NodeShared: z.ZodObject<{
         read: "read";
     }>;
     parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type NodeShared = z.infer<typeof NodeShared>;
 export declare const NodeGrantRevokeInput: z.ZodObject<{
     nodeId: z.ZodTemplateLiteral<`node_${string}`>;
@@ -89,5 +89,5 @@ export declare const NodeGrantRevoked: z.ZodObject<{
     nodeId: z.ZodTemplateLiteral<`node_${string}`>;
     grantId: z.ZodTemplateLiteral<`grant_${string}`>;
     parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type NodeGrantRevoked = z.infer<typeof NodeGrantRevoked>;

package/dist/grants/grants.js

@@ -19,7 +19,7 @@ export const NodeGrantListInput = z.strictObject({
     limit: PageSize.optional().describe("How many people one page holds, 1 to 100. Leaving it out gives 100."),
 });
 // One person who reaches the node, with the strongest right they hold and where it comes from.
-export const NodeGrant = z.strictObject({
+export const NodeGrant = z.object({
     // The grant to revoke: on this node, or on the folder `inheritedFrom`. Null for the creator of the
     // node or of a folder above it, whose right is no grant.
     grantId: GrantId.nullable(),
@@ -34,9 +34,9 @@ export const NodeGrant = z.strictObject({
     // Made this node: holds every right, and nobody takes it.
     creator: z.boolean(),
     // The folder the right comes from; null when it stands on this node.
-    inheritedFrom: z.strictObject({ nodeId: NodeId, name: z.string() }).nullable(),
+    inheritedFrom: z.object({ nodeId: NodeId, name: z.string() }).nullable(),
 });
-export const NodeGrantList = z.strictObject({
+export const NodeGrantList = z.object({
     items: z.array(NodeGrant),
     nextCursor: z.string().nullable(),
 });
@@ -45,7 +45,7 @@ export const NodeShareInput = z.strictObject({
     userId: idSchema("user").describe("The person or machine to share with, `user_…`, as intelligence_user_list finds them. A locked account cannot be given a right."),
     right: GrantRight.describe("read sees the node, write also changes it, share also shares it further. Sharing again with someone who holds a grant sets their right to this one. A node in its creator's own area moves to the top level of Shared."),
 });
-export const NodeShared = z.strictObject({
+export const NodeShared = z.object({
     nodeId: NodeId,
     grantId: GrantId,
     userId: z.string(),
@@ -57,7 +57,7 @@ export const NodeGrantRevokeInput = z.strictObject({
     nodeId: NodeId,
     grantId: GrantId.describe("The grant to take back, as intelligence_node_grant_list names it for this node. One on the node itself falls; one on a folder above stays there, and the node moves out of that folder to the top level of Shared with only its own grants."),
 });
-export const NodeGrantRevoked = z.strictObject({
+export const NodeGrantRevoked = z.object({
     nodeId: NodeId,
     grantId: GrantId,
     // Where the node stands now: null is the top level of Shared; its creator's root folder when its

package/dist/instructions/instructions.d.ts

@@ -6,14 +6,14 @@ export declare const InstructionsLink: z.ZodObject<{
     path: z.ZodString;
     status: z.ZodNullable<z.ZodString>;
     markdown: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type InstructionsLink = z.infer<typeof InstructionsLink>;
 export declare const Instructions: z.ZodObject<{
     chain: z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         status: z.ZodNullable<z.ZodString>;
         markdown: z.ZodString;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     hint: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type Instructions = z.infer<typeof Instructions>;

package/dist/instructions/instructions.js

@@ -16,7 +16,7 @@ export function isInstructionsName(name) {
     return instructionsNames.includes(name);
 }
 // One link of the chain, top down.
-export const InstructionsLink = z.strictObject({
+export const InstructionsLink = z.object({
     // Where it stands, as the caller can read it, from the first readable folder below a root folder
     // down to the document itself: `Vertrieb/Leads/.INSTRUCTIONS`.
     path: z.string(),
@@ -28,7 +28,7 @@ export const InstructionsLink = z.strictObject({
     // `# @name` sections.
     markdown: z.string(),
 });
-export const Instructions = z.strictObject({
+export const Instructions = z.object({
     chain: z.array(InstructionsLink),
     // Only when the whole chain holds more than 3,000 words (E67): one English sentence.
     hint: z.string().optional(),

package/dist/interfaces/interfaces.d.ts

@@ -22,7 +22,7 @@ export declare const InterfaceRemoved: z.ZodObject<{
     name: z.ZodString;
     functions: z.ZodArray<z.ZodString>;
     permissions: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type InterfaceRemoved = z.infer<typeof InterfaceRemoved>;
 export declare const ServiceInterfaceDeclareInput: z.ZodObject<{
     functions: z.ZodArray<z.ZodString>;

package/dist/interfaces/interfaces.js

@@ -26,7 +26,7 @@ export const ServiceInterfaceRemoveInput = z.strictObject({
 });
 // What fell with a removed interface: its functions and the rights the roles held on them (trap
 // P334: the answer names what fell, so the caller can read it).
-export const InterfaceRemoved = z.strictObject({
+export const InterfaceRemoved = z.object({
     interfaceId: InterfaceId,
     name: z.string(),
     functions: z.array(z.string()),

package/dist/invitations/invitations.d.ts

@@ -3,12 +3,12 @@ export declare const InvitationId: z.ZodTemplateLiteral<`invitation_${string}`>;
 export declare const RoleChip: z.ZodObject<{
     roleId: z.ZodTemplateLiteral<`role_${string}`>;
     name: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type RoleChip = z.infer<typeof RoleChip>;
 export declare const Delivery: z.ZodObject<{
     accepted: z.ZodBoolean;
     cause: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type Delivery = z.infer<typeof Delivery>;
 export declare const InvitationCreateInput: z.ZodObject<{
     email: z.ZodEmail;
@@ -36,7 +36,7 @@ export declare const Invitation: z.ZodObject<{
     roles: z.ZodArray<z.ZodObject<{
         roleId: z.ZodTemplateLiteral<`role_${string}`>;
         name: z.ZodString;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     status: z.ZodEnum<{
         accepted: "accepted";
         invited: "invited";
@@ -46,7 +46,7 @@ export declare const Invitation: z.ZodObject<{
     invitedBy: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
     expiresAt: z.ZodISODateTime;
     createdAt: z.ZodISODateTime;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type Invitation = z.infer<typeof Invitation>;
 export declare const InvitationSent: z.ZodObject<{
     invitationId: z.ZodTemplateLiteral<`invitation_${string}`>;
@@ -54,7 +54,7 @@ export declare const InvitationSent: z.ZodObject<{
     roles: z.ZodArray<z.ZodObject<{
         roleId: z.ZodTemplateLiteral<`role_${string}`>;
         name: z.ZodString;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     status: z.ZodEnum<{
         accepted: "accepted";
         invited: "invited";
@@ -67,8 +67,8 @@ export declare const InvitationSent: z.ZodObject<{
     delivery: z.ZodObject<{
         accepted: z.ZodBoolean;
         cause: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export type InvitationSent = z.infer<typeof InvitationSent>;
 export declare const InvitationLookupQuery: z.ZodObject<{
     token: z.ZodString;
@@ -79,7 +79,7 @@ export declare const InvitationLookup: z.ZodObject<{
     inviter: z.ZodNullable<z.ZodString>;
     expired: z.ZodBoolean;
     expiresAt: z.ZodISODateTime;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type InvitationLookup = z.infer<typeof InvitationLookup>;
 export declare const InvitationAcceptInput: z.ZodObject<{
     token: z.ZodString;

package/dist/invitations/invitations.js

@@ -7,9 +7,9 @@ import { RoleId } from "../roles/roles.js";
 // days, carries one valid token at a time, and its roles become the person's on acceptance.
 export const InvitationId = idSchema("invitation");
 // A role as the list shows it: its id for the next call, its name for the chip.
-export const RoleChip = z.strictObject({ roleId: RoleId, name: z.string() });
+export const RoleChip = z.object({ roleId: RoleId, name: z.string() });
 // What `send` of the package `mail` answered: a failed delivery is an answer, not an exception.
-export const Delivery = z.strictObject({ accepted: z.boolean(), cause: z.string().optional() });
+export const Delivery = z.object({ accepted: z.boolean(), cause: z.string().optional() });
 // The roles a new account gets. Without the field, `mitglied` (E9); an empty list invites to no role.
 const RoleIds = z.array(RoleId).max(50);
 export const InvitationCreateInput = z.strictObject({
@@ -21,7 +21,7 @@ export const InvitationRevokeInput = z.strictObject({ invitationId: InvitationId
 // `invited` while the link works, `expired` once its seven days passed (a resend restarts them),
 // `revoked` after a withdrawal and `accepted` once the account exists.
 export const InvitationStatus = z.enum(["invited", "expired", "revoked", "accepted"]);
-export const Invitation = z.strictObject({
+export const Invitation = z.object({
     invitationId: InvitationId,
     email: z.string(),
     roles: z.array(RoleChip),
@@ -35,7 +35,7 @@ export const Invitation = z.strictObject({
 export const InvitationSent = Invitation.extend({ delivery: Delivery });
 // `GET /auth/invitation?token=…`, read by the page the invitation link opens (auth-invite.png).
 export const InvitationLookupQuery = z.strictObject({ token: z.string().min(1).max(200) });
-export const InvitationLookup = z.strictObject({
+export const InvitationLookup = z.object({
     email: z.string(),
     // The display name of whoever invited, or null when that account is gone.
     inviter: z.string().nullable(),

package/dist/links/links.d.ts

@@ -51,7 +51,7 @@ export declare const NodeLink: z.ZodObject<{
     createdByName: z.ZodNullable<z.ZodString>;
     createdAt: z.ZodISODateTime;
     updatedAt: z.ZodISODateTime;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type NodeLink = z.infer<typeof NodeLink>;
 export declare const NodeLinkList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
@@ -70,7 +70,7 @@ export declare const NodeLinkList: z.ZodObject<{
         createdByName: z.ZodNullable<z.ZodString>;
         createdAt: z.ZodISODateTime;
         updatedAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`link_${string}`>>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type NodeLinkList = z.infer<typeof NodeLinkList>;

package/dist/links/links.js

@@ -54,7 +54,7 @@ export const NodeLinkRevokeInput = z.strictObject({
 export const LinkStatus = z.enum(["active", "expired", "revoked", "inactive"]);
 // One link. `url` is derived from the id every time it is answered and never stored: the table holds
 // only the hash of its token.
-export const NodeLink = z.strictObject({
+export const NodeLink = z.object({
     linkId: LinkId,
     nodeId: NodeId,
     url: z.url(),
@@ -67,7 +67,7 @@ export const NodeLink = z.strictObject({
     createdAt: z.iso.datetime(),
     updatedAt: z.iso.datetime(),
 });
-export const NodeLinkList = z.strictObject({
+export const NodeLinkList = z.object({
     items: z.array(NodeLink),
     nextCursor: LinkId.nullable(),
 });

package/dist/machines/machines.d.ts

@@ -38,7 +38,7 @@ export declare const MachineKey: z.ZodObject<{
         roles: z.ZodArray<z.ZodObject<{
             roleId: z.ZodTemplateLiteral<`role_${string}`>;
             name: z.ZodString;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         status: z.ZodNullable<z.ZodEnum<{
             archived: "archived";
             invited: "invited";
@@ -51,19 +51,19 @@ export declare const MachineKey: z.ZodObject<{
                 external: "external";
             }>;
             responsibleId: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         createdAt: z.ZodISODateTime;
         updatedAt: z.ZodISODateTime;
-    }, z.core.$strict>;
+    }, z.core.$strip>;
     key: z.ZodString;
     mcpUrl: z.ZodString;
     tokenUrl: z.ZodString;
     example: z.ZodString;
     docs: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type MachineKey = z.infer<typeof MachineKey>;
 export declare const MachinePurged: z.ZodObject<{
     machineId: z.ZodTemplateLiteral<`user_${string}`>;
     name: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type MachinePurged = z.infer<typeof MachinePurged>;

package/dist/machines/machines.js

@@ -24,7 +24,7 @@ export const MachinePurgeInput = z.strictObject({ machineId: MachineId });
 // The answer of create and rotate: the key, shown ONCE (it is stored hashed), and how to connect the
 // machine ("So verbindest du sie"). ⚠️ These two tools are the only ones whose result carries a key
 // (`revealsSecret` on the tool).
-export const MachineKey = z.strictObject({
+export const MachineKey = z.object({
     machine: User,
     key: z.string(),
     // `<origin>/mcp`, the one address every machine talks to.
@@ -36,4 +36,4 @@ export const MachineKey = z.strictObject({
     docs: z.string(),
 });
 // What fell, by name (trap P334): after the purge nothing else can be read about it.
-export const MachinePurged = z.strictObject({ machineId: MachineId, name: z.string() });
+export const MachinePurged = z.object({ machineId: MachineId, name: z.string() });

package/dist/messages/messages.d.ts

@@ -38,9 +38,9 @@ export declare const MessageAuthor: z.ZodObject<{
             codex: "codex";
             gemini: "gemini";
         }>>;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     appHandle: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type MessageAuthor = z.infer<typeof MessageAuthor>;
 export declare const Message: z.ZodObject<{
     messageId: z.ZodTemplateLiteral<`message_${string}`>;
@@ -63,15 +63,15 @@ export declare const Message: z.ZodObject<{
                 codex: "codex";
                 gemini: "gemini";
             }>>;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         appHandle: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>;
+    }, z.core.$strip>;
     mentions: z.ZodArray<z.ZodObject<{
         userId: z.ZodString;
         name: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     createdAt: z.ZodISODateTime;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type Message = z.infer<typeof Message>;
 export declare const MessageList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
@@ -95,23 +95,23 @@ export declare const MessageList: z.ZodObject<{
                     codex: "codex";
                     gemini: "gemini";
                 }>>;
-            }, z.core.$strict>>;
+            }, z.core.$strip>>;
             appHandle: z.ZodNullable<z.ZodString>;
-        }, z.core.$strict>;
+        }, z.core.$strip>;
         mentions: z.ZodArray<z.ZodObject<{
             userId: z.ZodString;
             name: z.ZodNullable<z.ZodString>;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         createdAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
     unreadCount: z.ZodNumber;
     readUntil: z.ZodNullable<z.ZodTemplateLiteral<`message_${string}`>>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type MessageList = z.infer<typeof MessageList>;
 export declare const ChatRead: z.ZodObject<{
     chatId: z.ZodTemplateLiteral<`node_${string}`>;
     readUntil: z.ZodNullable<z.ZodTemplateLiteral<`message_${string}`>>;
     unreadCount: z.ZodNumber;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type ChatRead = z.infer<typeof ChatRead>;

package/dist/messages/messages.js

@@ -43,7 +43,7 @@ export const ChatUpdateInput = z.strictObject({
 // Who wrote a message. A person writing in the browser has no `appHandle`; their AI writing through a
 // connected app carries that app's name. A machine carries its kind and an Operator its provider.
 // The UI makes the sentence of it ("Max Member via Claude Code", "Validierung · Claude", "Lead-Import").
-export const MessageAuthor = z.strictObject({
+export const MessageAuthor = z.object({
     userId: z.string(),
     // As `access` names them today; null for an account that is gone.
     name: z.string().nullable(),
@@ -52,15 +52,15 @@ export const MessageAuthor = z.strictObject({
     machine: MessageMachine.nullable(),
     appHandle: z.string().nullable(),
 });
-export const Message = z.strictObject({
+export const Message = z.object({
     messageId: MessageId,
     nodeId: NodeId,
     text: z.string(),
     author: MessageAuthor,
-    mentions: z.array(z.strictObject({ userId: z.string(), name: z.string().nullable() })),
+    mentions: z.array(z.object({ userId: z.string(), name: z.string().nullable() })),
     createdAt: z.iso.datetime(),
 });
-export const MessageList = z.strictObject({
+export const MessageList = z.object({
     // Oldest first, as a chat reads.
     items: z.array(Message),
     // The page before this one; null when there is none, and always with `after`.
@@ -70,7 +70,7 @@ export const MessageList = z.strictObject({
     unreadCount: z.number().int(),
     readUntil: MessageId.nullable(),
 });
-export const ChatRead = z.strictObject({
+export const ChatRead = z.object({
     chatId: NodeId,
     readUntil: MessageId.nullable(),
     unreadCount: z.number().int(),