@tai42/api-client 19.3.0 → 20.0.0

package/src/generated/served-schemas.ts

@@ -12,12 +12,6 @@ import { templatedText } from '../templated-text';
 export const hookSubject = z.object({ "key_expr": templatedText, "kind": z.string(), "target_kind": z.enum(["agent","tool"]), "target_name": z.string().min(1) }).strict();
 export type HookSubject = z.infer<typeof hookSubject>;
 
-export const mediaKind = z.enum(["image","link","document","video","audio"]);
-export type MediaKind = z.infer<typeof mediaKind>;
-
-export const mediaItem = z.object({ "caption": z.union([z.string(), z.null()]).default(null), "filename": z.union([z.string(), z.null()]).default(null), "kind": mediaKind, "url": z.string() });
-export type MediaItem = z.infer<typeof mediaItem>;
-
 export const overlapPolicy = z.object({ "deliver": z.enum(["one","all"]).default("one"), "running": z.enum(["continue","cancel"]).default("continue"), "settle_seconds": z.number().int().gte(0).lte(30).default(0) });
 export type OverlapPolicy = z.infer<typeof overlapPolicy>;
 
@@ -27,9 +21,6 @@ export type PresetSeedToolMeta = z.infer<typeof presetSeedToolMeta>;
 export const presetSpec = z.object({ "base_tool": z.string(), "description": z.string().default(""), "fixed_kwargs": z.record(z.string(), z.unknown()).default({}), "name": z.string() });
 export type PresetSpec = z.infer<typeof presetSpec>;
 
-export const quickReplyButtonParam = z.object({ "kind": z.literal("quick_reply").default("quick_reply"), "payload": z.string() });
-export type QuickReplyButtonParam = z.infer<typeof quickReplyButtonParam>;
-
 export const stateInjection = z.object({ "into": z.string().min(1), "jq": z.union([templatedText, z.null()]).default(null), "template_jq": z.union([z.string(), z.null()]).default(null) }).strict();
 export type StateInjection = z.infer<typeof stateInjection>;
 
@@ -54,48 +45,13 @@ export type StateTemplateReconcile = z.infer<typeof stateTemplateReconcile>;
 export const subAgentSpec: z.ZodType = z.lazy(() => z.object({ "description": z.string().default(""), "inline_skills": z.array(z.record(z.string(), z.unknown())).default([]), "name": z.string(), "presets": z.array(presetSpec).default([]), "response_format": z.union([z.unknown(), templatedText, z.record(z.string(), z.unknown()), z.null()]).default(null), "skills": z.array(z.string()).default([]), "strategy": z.union([z.string(), z.null()]).default(null), "subagents": z.array(subAgentSpec).default([]), "system_prompt": z.union([templatedText, z.null()]).default(null), "tool_names": z.array(z.string()).default([]), "tools": z.array(z.unknown()).default([]) }));
 export type SubAgentSpec = z.infer<typeof subAgentSpec>;
 
-export const urlButtonParam = z.object({ "kind": z.literal("url").default("url"), "url_parameter": z.string() });
-export type UrlButtonParam = z.infer<typeof urlButtonParam>;
-
 export const accessPolicy = z.object({ "condition": z.union([templatedText, z.null()]).default(null), "policy_data": z.record(z.string(), z.unknown()).default({}), "scopes": z.array(z.string()).default([]) });
 export type AccessPolicy = z.infer<typeof accessPolicy>;
 
 export const callbackSchema = z.object({ "carried_kwargs": z.record(z.string(), z.unknown()).default({}), "condition": z.union([templatedText, z.null()]).default(null), "expr": z.union([templatedText, z.null()]).default(null), "tool": z.string().default("") });
 export type CallbackSchema = z.infer<typeof callbackSchema>;
 
-export const channelTemplate = z.object({ "body_parameters": z.array(z.string()).default([]), "buttons": z.array(z.unknown().superRefine((x, ctx) => {
-    const schemas = [quickReplyButtonParam, urlButtonParam];
-    const { errors, failed } = schemas.reduce<{
-      errors: z.core.$ZodIssue[];
-      failed: number;
-    }>(
-      ({ errors, failed }, schema) =>
-        ((result) =>
-          result.error
-            ? {
-                errors: [...errors, ...result.error.issues],
-                failed: failed + 1,
-              }
-            : { errors, failed })(
-          schema.safeParse(x),
-        ),
-      { errors: [], failed: 0 },
-    );
-    const passed = schemas.length - failed;
-    if (passed !== 1) {
-      ctx.addIssue(errors.length ? {
-        path: [],
-        code: "invalid_union",
-        errors: [errors],
-        message: "Invalid input: Should pass single schema. Passed " + passed,
-      } : {
-        path: [],
-        code: "custom",
-        errors: [errors],
-        message: "Invalid input: Should pass single schema. Passed " + passed,
-      });
-    }
-  })).default([]), "header_media": z.union([mediaItem, z.null()]).default(null), "language": z.string(), "name": z.string() });
+export const channelTemplate = z.object({ "language": z.string(), "name": z.string(), "parameters": z.union([z.record(z.string(), z.unknown()), z.null()]).default(null) });
 export type ChannelTemplate = z.infer<typeof channelTemplate>;
 
 export const conversationRoute = z.object({ "callback_secret": z.union([z.string(), z.null()]).default(null), "callback_url": z.union([z.string(), z.null()]).default(null), "cancel_expr": z.union([templatedText, z.null()]).default(null), "channel": z.union([z.string(), z.null()]).default(null), "door": z.enum(["api","channel"]), "error_reply_text": z.union([z.string().min(1).max(2000), z.null()]).default(null), "execution_key": z.string().min(1), "execution_key_fingerprint": z.string().min(1), "extras_expr": z.union([templatedText, z.null()]).default(null), "initial_mode": z.enum(["agent","manual"]).default("agent"), "locale": z.union([z.string(), z.null()]).default(null), "our_identity": z.union([z.string(), z.null()]).default(null), "overlap": overlapPolicy.default({"deliver":"one","running":"continue","settle_seconds":0}), "reply_expr": z.union([templatedText, z.null()]).default(null), "resume_expr": z.union([templatedText, z.null()]).default(null), "route_name": z.string(), "start_expr": z.union([templatedText, z.null()]).default(null), "target_kind": z.enum(["agent","tool"]), "target_name": z.string().min(1), "turns_per_hour_override": z.union([z.number().int().gt(0), z.null()]).default(null) });

package/src/index.ts

@@ -142,6 +142,8 @@ export type {
   InteractionCancelled,
   InteractionMediaItem,
   InteractionsPage,
+  InviteRow,
+  InvokeMemberActionResult,
   KindStatus,
   LoginFormField,
   LoginMethod,
@@ -180,6 +182,12 @@ export type {
   McpEnvRefs,
   McpReloadResult,
   MediaKind,
+  MemberActionCatalog,
+  MemberActionDescriptor,
+  MemberActionScope,
+  MemberDirectory,
+  MemberPrincipalState,
+  MemberRow,
   MeProjection,
   Notification,
   Notifications,

package/src/schemas/index.ts

@@ -15,6 +15,7 @@ export * from './interactions';
 export * from './login';
 export * from './manifest-mcp';
 export * from './marketplace';
+export * from './members';
 export * from './notifications';
 export * from './observability';
 export * from './policy';

package/src/schemas/members.ts

@@ -0,0 +1,121 @@
+/** Member, invite, directory and member-action schemas for the generic Members view. */
+import { z } from 'zod';
+
+import { jsonSchema } from './shared';
+
+/**
+ * Where a declared member action renders: a page-level button, a member-row menu
+ * item, or an invite-row menu item. A provider classifies each of its own actions
+ * into one of these three places; Studio only joins by `scope`, never reads the
+ * provider's meaning behind it.
+ */
+export const memberActionScope = z.enum(['page', 'member_row', 'invite_row']);
+export type MemberActionScope = z.infer<typeof memberActionScope>;
+
+/**
+ * One platform principal a member holds (`GET /api/auth/members` →
+ * `members[].principals[]`). `user_id` is the platform principal id; `disabled` is
+ * taken from that principal's own record (the store the principals listing reads),
+ * never from a provider.
+ */
+export const memberPrincipalState = z.object({
+  user_id: z.string(),
+  disabled: z.boolean(),
+});
+export type MemberPrincipalState = z.infer<typeof memberPrincipalState>;
+
+/**
+ * One person an accounts provider owns, as the directory door returns them
+ * (`GET /api/auth/members` → `members[]`). `id` is the provider's stable handle for
+ * the person (a list key, not shown). `email` is the sign-in identity; `role` names
+ * the platform role the person holds (the NAME only — the role definition is read
+ * from the role listing). `principals` carries each principal's platform-joined
+ * state; `disabled` is derived True only when EVERY principal is disabled, so a
+ * person with any enabled principal still reads active while the per-principal truth
+ * stays visible. `handle` routes an invoke back to the producing provider and pins
+ * this row; `action_keys` are the opaque catalog keys of the actions applicable to
+ * it — Studio joins and echoes both, never parses them. `created_at` is an ISO-8601
+ * instant.
+ */
+export const memberRow = z.object({
+  id: z.string(),
+  email: z.string(),
+  role: z.string(),
+  created_at: z.string(),
+  principals: z.array(memberPrincipalState),
+  disabled: z.boolean(),
+  handle: z.string(),
+  action_keys: z.array(z.string()),
+});
+export type MemberRow = z.infer<typeof memberRow>;
+
+/**
+ * One outstanding invitation an accounts provider holds, as the directory door
+ * returns them (`GET /api/auth/members` → `invites[]`). `id` is the provider's
+ * stable handle for the invited person; `email` is the invited address; `role` names
+ * the platform role they will hold (name only, as on {@link memberRow}). An
+ * invitation holds no principal, so it carries no principal state. `handle` and
+ * `action_keys` are the opaque routing tokens (see {@link memberRow}). `created_at`
+ * and `expires_at` are ISO-8601 instants.
+ */
+export const inviteRow = z.object({
+  id: z.string(),
+  email: z.string(),
+  role: z.string(),
+  created_at: z.string(),
+  expires_at: z.string(),
+  handle: z.string(),
+  action_keys: z.array(z.string()),
+});
+export type InviteRow = z.infer<typeof inviteRow>;
+
+/**
+ * The deployment-wide membership (`GET /api/auth/members`): every accounts
+ * provider's people and outstanding invitations, aggregated and platform-joined by
+ * the backend into one view so a generic Members screen renders without naming any
+ * provider.
+ */
+export const memberDirectory = z.object({
+  members: z.array(memberRow),
+  invites: z.array(inviteRow),
+});
+export type MemberDirectory = z.infer<typeof memberDirectory>;
+
+/**
+ * One declared member action, serialized for the catalog (`GET
+ * /api/auth/member-actions` → `actions[]`). `key` is the opaque catalog key a caller
+ * joins and echoes, never parses. `label` is the resolved wording. `scope` places
+ * the action; `destructive` asks for a confirm before invoking. `input_schema` and
+ * `result_schema` are the declared models' JSON Schema — a caller renders an input
+ * form and a read-only result view from them generically, with no provider field
+ * name known to Studio.
+ */
+export const memberActionDescriptor = z.object({
+  key: z.string(),
+  label: z.string(),
+  scope: memberActionScope,
+  destructive: z.boolean(),
+  input_schema: jsonSchema,
+  result_schema: jsonSchema,
+});
+export type MemberActionDescriptor = z.infer<typeof memberActionDescriptor>;
+
+/**
+ * Every declared member action across the registered accounts providers (`GET
+ * /api/auth/member-actions`). ADMIN-ONLY (`secret`) — a non-admin projection never
+ * reaches the route, exactly as the members listing.
+ */
+export const memberActionCatalog = z.object({
+  actions: z.array(memberActionDescriptor),
+});
+export type MemberActionCatalog = z.infer<typeof memberActionCatalog>;
+
+/**
+ * The invoke-door result (`POST /api/auth/member-actions/invoke`): the provider's
+ * result-model dump, carried opaquely. `result` is rendered through the action's
+ * `result_schema`; Studio reads no field of it by name.
+ */
+export const invokeMemberActionResult = z.object({
+  result: jsonSchema,
+});
+export type InvokeMemberActionResult = z.infer<typeof invokeMemberActionResult>;