Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
feat(agents): load the user's skills a request needs before each turn (#9550)
Wolf Mermelsteine8c9ae65f141
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.jsonindex 2b285e23dc..e6fe2578cb 100644--- a/.github/workspace-dep-closures.json+++ b/.github/workspace-dep-closures.json@@ -12950,6 +12950,7 @@"crates/call","crates/channel_sender","crates/channels",+ "crates/cognition","crates/comms_db_client","crates/connection","crates/connection_gateway_client",diff --git a/.sqlx/query-4c11b48b175dee7bdb9b73b1b9290ba214d77e12ad73074331553dca8d46eaaf.json b/.sqlx/query-4c11b48b175dee7bdb9b73b1b9290ba214d77e12ad73074331553dca8d46eaaf.jsonnew file mode 100644index 0000000000..daaaa46b3b--- /dev/null+++ b/.sqlx/query-4c11b48b175dee7bdb9b73b1b9290ba214d77e12ad73074331553dca8d46eaaf.json@@ -0,0 +1,15 @@+{+ "db_name": "PostgreSQL",+ "query": "\n INSERT INTO skill_description (document_id, description)\n VALUES ($1, $2)\n ON CONFLICT (document_id)\n DO UPDATE SET description = EXCLUDED.description, updated_at = now()\n ",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Text",+ "Text"+ ]+ },+ "nullable": []+ },+ "hash": "4c11b48b175dee7bdb9b73b1b9290ba214d77e12ad73074331553dca8d46eaaf"+}diff --git a/.sqlx/query-682109cfb504c72be42f137fe8b40a232d7beff42d7a5e27da3b8940e5adfbf4.json b/.sqlx/query-682109cfb504c72be42f137fe8b40a232d7beff42d7a5e27da3b8940e5adfbf4.jsonnew file mode 100644index 0000000000..1d1d8151f7--- /dev/null+++ b/.sqlx/query-682109cfb504c72be42f137fe8b40a232d7beff42d7a5e27da3b8940e5adfbf4.json@@ -0,0 +1,28 @@+{+ "db_name": "PostgreSQL",+ "query": "\n SELECT document_id, description\n FROM skill_description\n WHERE document_id = ANY($1)\n ",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "document_id",+ "type_info": "Text"+ },+ {+ "ordinal": 1,+ "name": "description",+ "type_info": "Text"+ }+ ],+ "parameters": {+ "Left": [+ "TextArray"+ ]+ },+ "nullable": [+ false,+ false+ ]+ },+ "hash": "682109cfb504c72be42f137fe8b40a232d7beff42d7a5e27da3b8940e5adfbf4"+}diff --git a/Cargo.lock b/Cargo.lockindex 55075f4638..868544a2c0 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -733,6 +733,7 @@ dependencies = ["genai_telemetry","http 1.4.0","http-body-util",+ "jev","macro_user_id","macro_uuid","mcp_select",@@ -752,6 +753,7 @@ dependencies = ["schemars 1.2.1","serde","serde_json",+ "skills","sqlx","sse-stream","thiserror 2.0.18",@@ -761,6 +763,7 @@ dependencies = ["tracing-opentelemetry","tracing-subscriber","url",+ "uuid","workspace-hack",]@@ -18689,18 +18692,21 @@ dependencies = ["anyhow","async-trait","chrono",+ "cognition","cowlike","document_sub_type","documents","email","entity_access","filter_ast",+ "futures","item_filters","lexical_client","macro_user_id","models_pagination","models_search","models_soup",+ "rootcause","schemars 1.2.1","search_service_client","serde",@@ -18709,6 +18715,7 @@ dependencies = ["system_skills","thiserror 2.0.18","tokio",+ "tokio-util","tracing","uuid","workspace-hack",diff --git a/apps/docs/AI/mcp/tools/create-skill.mdx b/apps/docs/AI/mcp/tools/create-skill.mdxindex b109ce402c..f0b2008632 100644--- a/apps/docs/AI/mcp/tools/create-skill.mdx+++ b/apps/docs/AI/mcp/tools/create-skill.mdx@@ -2,17 +2,19 @@title: CreateSkilldescription: >-Create a skill: a markdown document of reusable instructions that AI reads and- follows when the skill is referenced, as Compose Skill in the app does.+ follows when the skill is referenced or a request needs it, as Compose Skill+ in the app does.---# CreateSkill-Create a skill: a markdown document of reusable instructions that AI reads and follows when the skill is referenced, as Compose Skill in the app does. Write the instructions as the markdown body. Edit an existing skill with EditDocument; find skills with ListSkills or SearchSkills.+Create a skill: a markdown document of reusable instructions that AI reads and follows when the skill is referenced or a request needs it, as Compose Skill in the app does. Write the instructions as the markdown body, and say in description when to use it. Edit an existing skill with EditDocument; find skills with ListSkills or SearchSkills.## Parameters| Parameter | Type | Required | Description || --- | --- | --- | --- || `skillName` | string | Yes | The skill's name. |+| `description` | string | Yes | When to use the skill, in one line starting "Use when", at most 300 characters, e.g. "Use when drafting release notes; not changelog entries". Agents load the skill for requests this describes. || `markdown` | string | Yes | The skill's instructions, in markdown. || `projectId` | string | No | The id of the project (shown as a folder in the app UI) to create the skill in. Requires edit access to the project. Omit to create it at the top level of the user's files. |diff --git a/apps/docs/product/skills.mdx b/apps/docs/product/skills.mdxindex 84a860bbe9..c959bec27f 100644--- a/apps/docs/product/skills.mdx+++ b/apps/docs/product/skills.mdx@@ -10,7 +10,7 @@ A skill is a saved set of instructions an [agent](/product/agents) follows, for## Creating a skill-Press <kbd>c</kbd> \+ <kbd>k</kbd> or choose **Skill** from the **Create** menu. Enter a name and instructions, then click **Create Skill**. **New skill** is also available from the `/` menu in an agent composer.+Press <kbd>c</kbd> \+ <kbd>k</kbd> or choose **Skill** from the **Create** menu. Enter a name, one line saying when to use it (for example "Use when drafting release notes; not changelogs"), and instructions, then click **Create Skill**. Edit the description under the title of an open skill. **New skill** is also available from the `/` menu in an agent composer.Skills are documents. They are stored in [Drive](/product/drive) and shared like other documents. Agents use the current version of a skill.@@ -18,7 +18,7 @@ Skills are documents. They are stored in [Drive](/product/drive) and shared likeType `/` in an agent composer to open the skills menu and attach a skill to the message. Skills can also be @mentioned.-Agents search your skills by name and use a matching skill without it being attached.+Agents search your skills by name and use a matching skill without it being attached. The description is what tells an agent a request needs the skill, so say when to use it, and when not to.## Built-in skillsdiff --git a/apps/web/src/features/block-md/component/ComposeSkill.tsx b/apps/web/src/features/block-md/component/ComposeSkill.tsxindex db14c5e5a9..702921d4fb 100644--- a/apps/web/src/features/block-md/component/ComposeSkill.tsx+++ b/apps/web/src/features/block-md/component/ComposeSkill.tsx@@ -26,7 +26,8 @@ import SplitIcon from '@icon/system/regular/square-half.svg';import XIcon from '@icon/system/regular/x.svg';import { mergeRegister } from '@lexical/utils';import { Telemetry } from '@macro-inc/observability';-import { Button, Hotkey, Scroll } from '@ui';+import { skillDescriptionProblem } from '@queries/storage/skill-description';+import { Button, Hotkey, Input, Scroll } from '@ui';import {$getRoot,COMMAND_PRIORITY_NORMAL,@@ -46,6 +47,7 @@ import {untrack,} from 'solid-js';import { EditorSystemMessage } from './EditorSystemMessage';+import { SKILL_DESCRIPTION_PLACEHOLDER } from './SkillDescriptionField';function composerTitleNavigationPlugin(bodyEditor: Accessor<LexicalEditor | undefined>@@ -186,12 +188,14 @@ function ComposeSkillTitleEditor(props: {export type ComposeSkillSuccess = {documentId: string;title: string;+ description: string;content: string;};export interface ComposeSkillProps {onClose?: () => void;initialTitle?: string;+ initialDescription?: string;initialContent?: string;placeholder?: string;/**@@ -204,7 +208,8 @@ export interface ComposeSkillProps {/*** Popover dialog for creating a skill — a trimmed-down sibling of- * [`ComposeTask`]: just a name, markdown instructions, and a create button.+ * [`ComposeTask`]: a name, a one-line "Use when …" description agents route+ * requests on, markdown instructions, and a create button.* Skills have no properties, tags, or assignees, so none of that appears.*/export function ComposeSkill(props: ComposeSkillProps) {@@ -212,6 +217,9 @@ export function ComposeSkill(props: ComposeSkillProps) {const { openWithSplit } = useSplitLayout();const [title, setTitle] = createSignal(props.initialTitle ?? '');+ const [description, setDescription] = createSignal(+ props.initialDescription ?? ''+ );const [content, setContent] = createSignal(props.initialContent ?? '');const [bodyEditor, setBodyEditor] = createSignal<LexicalEditor>();const [containerRef, setContainerRef] = createSignal<HTMLDivElement>();@@ -264,11 +272,13 @@ export function ComposeSkill(props: ComposeSkillProps) {// input instead of dropping it.const submitSkill = async () => {const skillTitle = title().trim();+ const skillDescription = description().trim();const skillContent = content().trim();setIsCreating(true);const documentId = await createSkill({title: skillTitle,+ description: skillDescription,content: skillContent,source: 'skill_composer',});@@ -284,6 +294,7 @@ export function ComposeSkill(props: ComposeSkillProps) {props.onSuccess?.({documentId,title: skillTitle,+ description: skillDescription,content: skillContent,});return documentId;@@ -296,6 +307,11 @@ export function ComposeSkill(props: ComposeSkillProps) {setErrorMessage('Please give this skill a name');return;}+ const descriptionProblem = skillDescriptionProblem(description());+ if (descriptionProblem) {+ setErrorMessage(descriptionProblem);+ return;+ }setErrorMessage('');const documentId = await submitSkill();@@ -306,6 +322,11 @@ export function ComposeSkill(props: ComposeSkillProps) {const handleContinueInSplit = async () => {if (isCreating()) return;+ const descriptionProblem = skillDescriptionProblem(description());+ if (descriptionProblem) {+ setErrorMessage(descriptionProblem);+ return;+ }setErrorMessage('');const documentId = await submitSkill();@@ -412,6 +433,29 @@ export function ComposeSkill(props: ComposeSkillProps) {/></div>+ <div class="shrink-0 px-2 mb-4">+ <Input+ variant="bare"+ size="sm"+ class="px-0 text-sm text-ink-muted"+ aria-label="When to use this skill"+ placeholder={SKILL_DESCRIPTION_PLACEHOLDER}+ maxLength={300}+ value={description()}+ disabled={isCreating()}+ onInput={(event) => {+ setDescription(event.currentTarget.value);+ if (errorMessage()) setErrorMessage('');+ }}+ onKeyDown={(event) => {+ if (event.key === 'Enter') {+ event.preventDefault();+ bodyEditor()?.focus();+ }+ }}+ />+ </div>+<div class="overflow-auto scrollbar-hidden mb-6 min-h-24 grow px-2"><Scroll><MarkdownShell@@ -436,7 +480,11 @@ export function ComposeSkill(props: ComposeSkillProps) {<div class="shrink-0 flex justify-end items-end gap-2"><ButtononClick={handleCreateSkill}- disabled={title().trim().length === 0 || isCreating()}+ disabled={+ title().trim().length === 0 ||+ description().trim().length === 0 ||+ isCreating()+ }variant="secondary"class="gap-3">diff --git a/apps/web/src/features/block-md/component/Notebook.tsx b/apps/web/src/features/block-md/component/Notebook.tsxindex 1b0cb4ba24..67742e8bd9 100644--- a/apps/web/src/features/block-md/component/Notebook.tsx+++ b/apps/web/src/features/block-md/component/Notebook.tsx@@ -47,6 +47,7 @@ import {outlineFitsGutter,useMarkdownOutline,} from './MarkdownOutline';+import { SkillDescriptionField } from './SkillDescriptionField';import { shouldAutofocusDocument } from './should-autofocus-document';import { TaskDuplicateMatchPill } from './TaskDuplicateMatches';import { TitleEditor } from './TitleEditor';@@ -378,6 +379,7 @@ export function Notebook(props: {><TitleEditor autoFocusOnMount={props.autoFocus} /><div class="spacer h-3" />+ <SkillDescriptionField /><div class="mb-6 flex flex-row flex-wrap items-center gap-2 text-sm empty:hidden"><InlineTaskProperties /><InlineTaskGithubPullRequests />diff --git a/apps/web/src/features/block-md/component/SkillDescriptionField.test.tsx b/apps/web/src/features/block-md/component/SkillDescriptionField.test.tsxnew file mode 100644index 0000000000..e0a6b3f854--- /dev/null+++ b/apps/web/src/features/block-md/component/SkillDescriptionField.test.tsx@@ -0,0 +1,72 @@+import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library';+import { afterEach, beforeEach, expect, it, vi } from 'vitest';++const document = vi.hoisted(() => ({ kind: 'skill' as string }));+const save = vi.hoisted(() => ({ mutate: vi.fn() }));++vi.mock('../context/markdown-document-context', () => ({+ useMarkdownDocument: () => ({+ documentId: () => 'skill-1',+ kind: () => document.kind,+ permissions: { canEdit: () => true },+ }),+}));++vi.mock('@queries/storage/skill-description', async (importOriginal) => ({+ ...(await importOriginal<+ typeof import('@queries/storage/skill-description')+ >()),+ useSkillDescriptionQuery: () => ({+ isSuccess: true,+ isPending: false,+ data: 'Use when drafting release notes',+ }),+ useSetSkillDescription: () => save,+}));++import { SkillDescriptionField } from './SkillDescriptionField';++beforeEach(() => {+ document.kind = 'skill';+ save.mutate.mockReset();+});+afterEach(cleanup);++function field() {+ return screen.getByLabelText('When to use this skill') as HTMLInputElement;+}++it('shows the stored description under a skill title', () => {+ render(() => <SkillDescriptionField />);+ expect(field().value).toBe('Use when drafting release notes');+});++it('rejects a line without "Use when" and saves nothing', () => {+ render(() => <SkillDescriptionField />);+ fireEvent.input(field(), { target: { value: 'Drafts release notes' } });+ fireEvent.blur(field());++ expect(+ screen.getByText('Start the description with "Use when".')+ ).toBeTruthy();+ expect(save.mutate).not.toHaveBeenCalled();+});++it('saves a changed description on blur', () => {+ render(() => <SkillDescriptionField />);+ fireEvent.input(field(), {+ target: { value: ' Use when drafting release notes; not changelogs ' },+ });+ fireEvent.blur(field());++ expect(save.mutate).toHaveBeenCalledWith(+ 'Use when drafting release notes; not changelogs',+ expect.anything()+ );+});++it('renders nothing for documents that are not skills', () => {+ document.kind = 'task';+ render(() => <SkillDescriptionField />);+ expect(screen.queryByLabelText('When to use this skill')).toBeNull();+});diff --git a/apps/web/src/features/block-md/component/SkillDescriptionField.tsx b/apps/web/src/features/block-md/component/SkillDescriptionField.tsxnew file mode 100644index 0000000000..e7be974f54--- /dev/null+++ b/apps/web/src/features/block-md/component/SkillDescriptionField.tsx@@ -0,0 +1,73 @@+import {+ skillDescriptionProblem,+ useSetSkillDescription,+ useSkillDescriptionQuery,+} from '@queries/storage/skill-description';+import { Input } from '@ui';+import { createEffect, createSignal, Show } from 'solid-js';+import { useMarkdownDocument } from '../context/markdown-document-context';+import { EditorSystemMessage } from './EditorSystemMessage';++/** Placeholder shared with the skill composer. */+export const SKILL_DESCRIPTION_PLACEHOLDER =+ 'Use when … ; not … — agents load this skill for requests it describes';++/**+ * When to use a skill, edited in place under its title. Agents load the skill+ * for requests this one line describes; it saves on blur or Enter.+ */+export function SkillDescriptionField() {+ const { documentId, kind, permissions } = useMarkdownDocument();+ if (kind() !== 'skill') return null;++ const query = useSkillDescriptionQuery(documentId);+ const save = useSetSkillDescription(documentId);+ const [draft, setDraft] = createSignal('');+ const [problem, setProblem] = createSignal<string>();+ createEffect(() => {+ if (query.isSuccess) setDraft(query.data ?? '');+ });++ const commit = () => {+ const text = draft().trim();+ if (text === (query.data ?? '')) return;+ const invalid = skillDescriptionProblem(text);+ setProblem(invalid);+ if (invalid) return;+ save.mutate(text, {+ onError: (error) => setProblem(error.message),+ });+ };++ return (+ <div class="mb-3 flex flex-col gap-1">+ <Input+ variant="bare"+ size="sm"+ class="px-0 text-sm text-ink-muted"+ aria-label="When to use this skill"+ aria-invalid={problem() ? true : undefined}+ placeholder={SKILL_DESCRIPTION_PLACEHOLDER}+ maxLength={300}+ value={draft()}+ disabled={!permissions.canEdit() || query.isPending}+ onInput={(event) => {+ setDraft(event.currentTarget.value);+ if (problem()) setProblem(undefined);+ }}+ onBlur={commit}+ onKeyDown={(event) => {+ if (event.key === 'Enter') {+ event.preventDefault();+ event.currentTarget.blur();+ }+ }}+ />+ <Show when={problem()}>+ {(message) => (+ <EditorSystemMessage variant="error">{message()}</EditorSystemMessage>+ )}+ </Show>+ </div>+ );+}diff --git a/apps/web/src/lib/core/util/create.ts b/apps/web/src/lib/core/util/create.tsindex f5c0e6ef8d..382dd8bf7b 100644--- a/apps/web/src/lib/core/util/create.ts+++ b/apps/web/src/lib/core/util/create.ts@@ -250,6 +250,8 @@ export async function createSnippet(type CreateSkillArgs = {title?: string;+ /** When to use the skill, in one line starting "Use when". */+ description: string;content?: string;projectId?: string;/** UI surface the creation originated from, for analytics. */@@ -263,12 +265,13 @@ type CreateSkillArgs = {* referenced in an AI input.*/export async function createSkill(- args?: CreateSkillArgs+ args: CreateSkillArgs): Promise<string | undefined> {const result = await storageServiceClient.createSkill({- skillName: args?.title ?? '',- markdown: args?.content ?? '',- projectId: args?.projectId,+ skillName: args.title ?? '',+ description: args.description,+ markdown: args.content ?? '',+ projectId: args.projectId,});fireAndForget(invalidateUserQuota(), 'create-entity');@@ -280,7 +283,7 @@ export async function createSkill(setPreviewOnCreate({itemId: documentId,itemType: 'document',- name: args?.title ?? '',+ name: args.title ?? '',fileType: 'md',subType: { type: 'skill' },});@@ -289,8 +292,8 @@ export async function createSkill(analytics.track('create_entity', {entityType: 'skill',entityId: documentId,- projectId: args?.projectId,- source: args?.source,+ projectId: args.projectId,+ source: args.source,});return documentId;diff --git a/apps/web/src/lib/queries/storage/skill-description.test.ts b/apps/web/src/lib/queries/storage/skill-description.test.tsnew file mode 100644index 0000000000..d7e4e57d6c--- /dev/null+++ b/apps/web/src/lib/queries/storage/skill-description.test.ts@@ -0,0 +1,25 @@+import { describe, expect, it } from 'vitest';+import { skillDescriptionProblem } from './skill-description';++describe('skillDescriptionProblem', () => {+ it('accepts one "Use when" line, whatever its case', () => {+ expect(+ skillDescriptionProblem(+ ' Use when drafting release notes; not changelogs '+ )+ ).toBeUndefined();+ expect(skillDescriptionProblem('use when triaging bugs')).toBeUndefined();+ });++ it('rejects blank, multi-line, long or unprefixed descriptions', () => {+ for (const invalid of [+ '',+ ' ',+ 'Use when one\nand two',+ 'Drafts release notes',+ `Use when ${'x'.repeat(300)}`,+ ]) {+ expect(skillDescriptionProblem(invalid)).toBeDefined();+ }+ });+});diff --git a/apps/web/src/lib/queries/storage/skill-description.ts b/apps/web/src/lib/queries/storage/skill-description.tsnew file mode 100644index 0000000000..d9ddba993c--- /dev/null+++ b/apps/web/src/lib/queries/storage/skill-description.ts@@ -0,0 +1,80 @@+import { storageServiceClient } from '@service-storage/client';+import {+ type QueryClient,+ useMutation,+ useQuery,+ useQueryClient,+} from '@tanstack/solid-query';++const MAX_CHARS = 300;+const OPENING = 'use when ';++/**+ * Why `text` is not a valid skill description, or undefined when it is. The+ * storage service applies the same rules: one line, at most 300 characters,+ * starting "Use when".+ */+export function skillDescriptionProblem(text: string): string | undefined {+ const trimmed = text.trim();+ if (!trimmed) return 'Describe when to use the skill, starting "Use when".';+ if (/[\r\n]/.test(trimmed)) return 'Keep the description to one line.';+ if (trimmed.length > MAX_CHARS)+ return `Keep the description to ${MAX_CHARS} characters or fewer.`;+ if (!trimmed.toLowerCase().startsWith(OPENING))+ return 'Start the description with "Use when".';+ return undefined;+}++const skillDescriptionKey = (documentId: string) =>+ ['storage', 'skill-description', documentId] as const;++async function fetchSkillDescription(documentId: string) {+ const result = await storageServiceClient.getSkillDescription({ documentId });+ if (result.isErr()) throw new Error('Failed to load skill description');+ return result.value.description ?? undefined;+}++async function saveSkillDescription(documentId: string, description: string) {+ const result = await storageServiceClient.setSkillDescription({+ documentId,+ description,+ });+ if (result.isErr())+ throw new Error(+ result.error[0]?.message ?? 'Failed to save skill description'+ );+ return result.value.description ?? undefined;+}++/** Query options for when to use the skill `documentId`. */+export function skillDescriptionQueryOptions(documentId: string) {+ return {+ queryKey: skillDescriptionKey(documentId),+ queryFn: () => fetchSkillDescription(documentId),+ };+}++/** When to use a skill: agents load it for requests this describes. */+export function useSkillDescriptionQuery(documentId: () => string) {+ return useQuery(() => skillDescriptionQueryOptions(documentId()));+}++function setSkillDescriptionMutationOptions(+ documentId: string,+ queryClient: QueryClient+) {+ return {+ mutationFn: (description: string) =>+ saveSkillDescription(documentId, description),+ onSuccess: (description: string | undefined) =>+ queryClient.setQueryData(skillDescriptionKey(documentId), description),+ };+}++/** Save when to use a skill. Rejects with the server's message when invalid. */+export function useSetSkillDescription(documentId: () => string) {+ const queryClient = useQueryClient();+ return useMutation(() =>+ setSkillDescriptionMutationOptions(documentId(), queryClient)+ );+}diff --git a/apps/web/src/lib/service-clients/service-cognition/generated/tools/schemas.ts b/apps/web/src/lib/service-clients/service-cognition/generated/tools/schemas.tsindex 15a0bd92ba..6fe742a2c4 100644--- a/apps/web/src/lib/service-clients/service-cognition/generated/tools/schemas.ts+++ b/apps/web/src/lib/service-clients/service-cognition/generated/tools/schemas.ts@@ -5428,6 +5428,7 @@ export const RoutineInfo = z.object({export const CreateSkill = z.object({skillName: z.string(),+ description: z.string(),markdown: z.string(),projectId: z.union([z.string().uuid(), z.null()]).optional(),});@@ -13210,6 +13211,7 @@ export const ListSkillsResponse = z.object({z.object({documentId: z.string().uuid(),name: z.string(),+ description: z.union([z.string(), z.null()]).optional(),updatedAt: z.union([z.string().datetime({ offset: true }), z.null()]).optional(),@@ -18380,6 +18382,7 @@ export const SearchSkillsResponse = z.object({z.object({documentId: z.string().uuid(),name: z.string(),+ description: z.union([z.string(), z.null()]).optional(),updatedAt: z.union([z.string().datetime({ offset: true }), z.null()]).optional(),diff --git a/apps/web/src/lib/service-clients/service-cognition/generated/tools/types.ts b/apps/web/src/lib/service-clients/service-cognition/generated/tools/types.tsindex b6fe4476b0..6ea58774f1 100644--- a/apps/web/src/lib/service-clients/service-cognition/generated/tools/types.ts+++ b/apps/web/src/lib/service-clients/service-cognition/generated/tools/types.ts@@ -8493,13 +8493,17 @@ export interface RoutineInfo {nextRunAt?: string | null;}/**- * Create a skill: a markdown document of reusable instructions that AI reads and follows when the skill is referenced, as Compose Skill in the app does. Write the instructions as the markdown body. Edit an existing skill with EditDocument; find skills with ListSkills or SearchSkills.+ * Create a skill: a markdown document of reusable instructions that AI reads and follows when the skill is referenced or a request needs it, as Compose Skill in the app does. Write the instructions as the markdown body, and say in description when to use it. Edit an existing skill with EditDocument; find skills with ListSkills or SearchSkills.*/export interface CreateSkill {/*** The skill's name.*/skillName: string;+ /**+ * When to use the skill, in one line starting "Use when", at most 300 characters, e.g. "Use when drafting release notes; not changelog entries". Agents load the skill for requests this describes.+ */+ description: string;/*** The skill's instructions, in markdown.*/@@ -12609,6 +12613,10 @@ export interface SkillSearchResult {* The name of the skill.*/name: string;+ /**+ * When to use the skill, when it says.+ */+ description?: string | null;/*** When the skill was last updated, when known.*/diff --git a/apps/web/src/lib/service-clients/service-storage/client.ts b/apps/web/src/lib/service-clients/service-storage/client.tsindex 0ddf44bfd8..5014119292 100644--- a/apps/web/src/lib/service-clients/service-storage/client.ts+++ b/apps/web/src/lib/service-clients/service-storage/client.ts@@ -165,6 +165,7 @@ import type { SetChannelPictureRequest } from './generated/schemas/setChannelPicimport type { SetCompanyNameRequest } from './generated/schemas/setCompanyNameRequest';import type { SetContactNameRequest } from './generated/schemas/setContactNameRequest';import type { SharePermissionV2 } from './generated/schemas/sharePermissionV2';+import type { SkillDescriptionBody } from './generated/schemas/skillDescriptionBody';import type { SlackCompleteRequest } from './generated/schemas/slackCompleteRequest';import type { SlackCreateRequest } from './generated/schemas/slackCreateRequest';import type { SlackRegisterRequest } from './generated/schemas/slackRegisterRequest';@@ -1657,6 +1658,24 @@ export const storageServiceClient = {/*** Gets the team-share state of a document (resolved against the owner's team).*/+ /** When to use a skill; `description` is absent for older skills. */+ async getSkillDescription(args: { documentId: string }) {+ return await dssFetch<SkillDescriptionBody>(+ `/documents/${args.documentId}/skill_description`+ );+ },++ /** Sets when to use a skill: one line starting "Use when". */+ async setSkillDescription(args: { documentId: string; description: string }) {+ return await dssFetch<SkillDescriptionBody>(+ `/documents/${args.documentId}/skill_description`,+ {+ method: 'PUT',+ body: JSON.stringify({ description: args.description }),+ }+ );+ },+async getDocumentTeamShare(args: { documentId: string }) {return await dssFetch<DocumentTeamShareResponse>(`/documents/${args.documentId}/team_share`diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/createSkillRequest.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/createSkillRequest.tsindex b7ccdf5124..aa68e36435 100644--- a/apps/web/src/lib/service-clients/service-storage/generated/schemas/createSkillRequest.ts+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/createSkillRequest.ts@@ -13,6 +13,10 @@ instructions that AI reads and follows when the skill is referenced in anAI input.*/export interface CreateSkillRequest {+ /** When to use the skill, in one line starting "Use when", e.g. "Use when+drafting release notes; not changelog entries". Agents choose skills+for a request by it. */+ description: string;/** Markdown source text. Defaults to an empty skill document. */markdown?: CreateSkillRequestMarkdown;/** Optional project ID to associate the skill with. */diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/index.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/index.tsindex 10f9b20cbc..75f7691f89 100644--- a/apps/web/src/lib/service-clients/service-storage/generated/schemas/index.ts+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/index.ts@@ -1834,6 +1834,7 @@ export * from './setPropertyValueOneOfThreeType';export * from './setPropertyValueOneOfTwoone';export * from './setPropertyValueOneOfTwooneType';export * from './setPropertyValueOneOfType';+export * from './setSkillDescriptionRequest';export * from './sha256Digest';export * from './sharedEmailFilter';export * from './sharedExternalChatReference';@@ -1847,6 +1848,8 @@ export * from './sharePermissionV2TeamShareAccessLevel';export * from './sharePipeline';export * from './shortIdResponse';export * from './simpleMention';+export * from './skillDescriptionBody';+export * from './skillDescriptionBodyDescription';export * from './skippedCell';export * from './skippedCellBy';export * from './slackCompleteRequest';diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/setSkillDescriptionRequest.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/setSkillDescriptionRequest.tsnew file mode 100644index 0000000000..73a4377fc0--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/setSkillDescriptionRequest.ts@@ -0,0 +1,15 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * Request body for setting a skill's routing description.+ */+export interface SetSkillDescriptionRequest {+ /** When to use the skill, in one line starting "Use when", at most 300+characters. */+ description: string;+}diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/skillDescriptionBody.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/skillDescriptionBody.tsnew file mode 100644index 0000000000..9344187ceb--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/skillDescriptionBody.ts@@ -0,0 +1,16 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */+import type { SkillDescriptionBodyDescription } from './skillDescriptionBodyDescription';++/**+ * A skill's routing description.+ */+export interface SkillDescriptionBody {+ /** When to use the skill, in one line starting "Use when". Absent for a+skill created before descriptions existed. */+ description?: SkillDescriptionBodyDescription;+}diff --git a/apps/web/src/lib/service-clients/service-storage/generated/schemas/skillDescriptionBodyDescription.ts b/apps/web/src/lib/service-clients/service-storage/generated/schemas/skillDescriptionBodyDescription.tsnew file mode 100644index 0000000000..da452b1c04--- /dev/null+++ b/apps/web/src/lib/service-clients/service-storage/generated/schemas/skillDescriptionBodyDescription.ts@@ -0,0 +1,12 @@+/**+ * Generated by orval v7.21.0 🍺+ * Do not edit manually.+ * document_storage_service+ * OpenAPI spec version: 0.1.0+ */++/**+ * When to use the skill, in one line starting "Use when". Absent for a+skill created before descriptions existed.+ */+export type SkillDescriptionBodyDescription = string | null;diff --git a/apps/web/src/lib/service-clients/service-storage/generated/zod.ts b/apps/web/src/lib/service-clients/service-storage/generated/zod.tsindex 2607ef134e..e4c4fcdd20 100644--- a/apps/web/src/lib/service-clients/service-storage/generated/zod.ts+++ b/apps/web/src/lib/service-clients/service-storage/generated/zod.ts@@ -17439,13 +17439,18 @@ export const createMarkdownHandlerResponse = zod.describe('Response for creating a markdown document.');/**- * @summary Creates a skill document with initialized markdown content in one-backend-owned lifecycle. Skills are markdown documents containing+ * @summary Creates a skill document with initialized markdown content and its+routing description in one backend-owned lifecycle. Skills are markdown documents containinginstructions that AI reads and follows when the skill is referenced in anAI input.*/export const createSkillHandlerBody = zod.object({+ description: zod+ .string()+ .describe(+ 'When to use the skill, in one line starting \"Use when\", e.g. \"Use when\ndrafting release notes; not changelog entries\". Agents choose skills\nfor a request by it.'+ ),markdown: zod.string().nullish()@@ -20038,6 +20043,54 @@ export const simpleSaveResponse = zod.object({error: zod.boolean().describe('Indicates if an error occurred'),});+/**+ * @summary Gets when to use a skill. `description` is absent for a skill created+before descriptions existed.+ */+export const getSkillDescriptionParams = zod.object({+ document_id: zod.string().describe('Skill document ID'),+});++export const getSkillDescriptionResponse = zod+ .object({+ description: zod+ .string()+ .nullish()+ .describe(+ 'When to use the skill, in one line starting \"Use when\". Absent for a\nskill created before descriptions existed.'+ ),+ })+ .describe("A skill's routing description.");++/**+ * @summary Sets when to use a skill: one line starting "Use when", at most 300+characters. Agents choose skills for a request by it.+ */+export const setSkillDescriptionParams = zod.object({+ document_id: zod.string().describe('Skill document ID'),+});++export const setSkillDescriptionBody = zod+ .object({+ description: zod+ .string()+ .describe(+ 'When to use the skill, in one line starting \"Use when\", at most 300\ncharacters.'+ ),+ })+ .describe("Request body for setting a skill's routing description.");++export const setSkillDescriptionResponse = zod+ .object({+ description: zod+ .string()+ .nullish()+ .describe(+ 'When to use the skill, in one line starting \"Use when\". Absent for a\nskill created before descriptions existed.'+ ),+ })+ .describe("A skill's routing description.");+/*** @summary Gets the team-share state of a document. The team is resolved from thedocument owner's team membership; `teamId` is omitted when the owner doesdiff --git a/apps/web/src/lib/service-clients/service-storage/openapi.json b/apps/web/src/lib/service-clients/service-storage/openapi.jsonindex 80485a4a3b..f358bb5b48 100644--- a/apps/web/src/lib/service-clients/service-storage/openapi.json+++ b/apps/web/src/lib/service-clients/service-storage/openapi.json@@ -9742,7 +9742,7 @@"/documents/create_skill": {"post": {"tags": ["document"],- "summary": "Creates a skill document with initialized markdown content in one\nbackend-owned lifecycle. Skills are markdown documents containing\ninstructions that AI reads and follows when the skill is referenced in an\nAI input.",+ "summary": "Creates a skill document with initialized markdown content and its\nrouting description in one backend-owned lifecycle. Skills are markdown documents containing\ninstructions that AI reads and follows when the skill is referenced in an\nAI input.","operationId": "create_skill_handler","requestBody": {"content": {@@ -9774,7 +9774,7 @@}},"400": {- "description": "",+ "description": "The description is blank, longer than one line or 300 characters, or does not start \"Use when\"","content": {"application/json": {"schema": {@@ -11822,6 +11822,144 @@}}},+ "/documents/{document_id}/skill_description": {+ "get": {+ "tags": ["document"],+ "summary": "Gets when to use a skill. `description` is absent for a skill created\nbefore descriptions existed.",+ "operationId": "get_skill_description",+ "parameters": [+ {+ "name": "document_id",+ "in": "path",+ "description": "Skill document ID",+ "required": true,+ "schema": {+ "type": "string"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/SkillDescriptionBody"+ }+ }+ }+ },+ "401": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "404": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "500": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ }+ }+ },+ "put": {+ "tags": ["document"],+ "summary": "Sets when to use a skill: one line starting \"Use when\", at most 300\ncharacters. Agents choose skills for a request by it.",+ "operationId": "set_skill_description",+ "parameters": [+ {+ "name": "document_id",+ "in": "path",+ "description": "Skill document ID",+ "required": true,+ "schema": {+ "type": "string"+ }+ }+ ],+ "requestBody": {+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/SetSkillDescriptionRequest"+ }+ }+ },+ "required": true+ },+ "responses": {+ "200": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/SkillDescriptionBody"+ }+ }+ }+ },+ "400": {+ "description": "The document is not a skill, or the description is invalid",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "401": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "404": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "500": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ }+ }+ }+ },"/documents/{document_id}/team_share": {"get": {"tags": ["document"],@@ -26792,8 +26930,12 @@"CreateSkillRequest": {"type": "object","description": "Request body for creating a skill — a markdown document containing\ninstructions that AI reads and follows when the skill is referenced in an\nAI input.",- "required": ["skillName"],+ "required": ["skillName", "description"],"properties": {+ "description": {+ "type": "string",+ "description": "When to use the skill, in one line starting \"Use when\", e.g. \"Use when\ndrafting release notes; not changelog entries\". Agents choose skills\nfor a request by it."+ },"markdown": {"type": ["string", "null"],"description": "Markdown source text. Defaults to an empty skill document."@@ -40679,6 +40821,17 @@],"description": "Type-safe enum for setting entity property values - provides compile-time validation."},+ "SetSkillDescriptionRequest": {+ "type": "object",+ "description": "Request body for setting a skill's routing description.",+ "required": ["description"],+ "properties": {+ "description": {+ "type": "string",+ "description": "When to use the skill, in one line starting \"Use when\", at most 300\ncharacters."+ }+ }+ },"Sha256Digest": {"type": "string","description": "SHA-256 encoded as exactly 64 lowercase hexadecimal characters."@@ -40831,6 +40984,16 @@}}},+ "SkillDescriptionBody": {+ "type": "object",+ "description": "A skill's routing description.",+ "properties": {+ "description": {+ "type": ["string", "null"],+ "description": "When to use the skill, in one line starting \"Use when\". Absent for a\nskill created before descriptions existed."+ }+ }+ },"SkippedCell": {"type": "object","description": "A cell an undo left alone, because someone changed it after the change\nbeing undone.",diff --git a/crates/agent_inmem/AGENTS.md b/crates/agent_inmem/AGENTS.mdindex 10990f6938..f1735f8aea 100644--- a/crates/agent_inmem/AGENTS.md+++ b/crates/agent_inmem/AGENTS.md@@ -76,6 +76,11 @@ DecideReview are eager internal tools in both standard and code modes.Opus 5.5 (hard), GPT-6.1 Sol (mid) or Gemini 3.8 Flash (simple, andwhenever Jev is unavailable). Capability lookups go through`models::resolve`.+- Owners with the `auto-skills` flag route each turn's request to their skills+ (`skills::domain::selection`, Jev, 1 s). Loaded skills are appended to the+ user message that loaded them in the model's copy only, and remembered per+ session in `SessionSkills` (memory; lost on restart). Eval:+ `route_evaluation` (ignored; needs `TYPESAFE_API_KEY`).- Keep session-aware `NameSearch`, `ContentSearch`, and `ListEntities` native incode mode; legacy `ReadChat` must not appear in either runtime tool catalog.- Every turn cuts tool results over `agent::ToolResultLimit`'s limit (aboutdiff --git a/crates/agent_inmem/Cargo.toml b/crates/agent_inmem/Cargo.tomlindex 28095f064c..a5f4cacca8 100644--- a/crates/agent_inmem/Cargo.toml+++ b/crates/agent_inmem/Cargo.toml@@ -47,6 +47,7 @@ rmcp = { workspace = true, features = ["client", "transport-streamable-http-clieschemars = { workspace = true }serde = { workspace = true }serde_json = { workspace = true }+skills = { path = "../skills" }sqlx = { workspace = true }sse-stream = { workspace = true }thiserror = { workspace = true }@@ -54,9 +55,11 @@ tokio = { workspace = true, features = ["sync", "rt", "time", "macros"] }tokio-util = { workspace = true }tracing = { workspace = true }url = { workspace = true }+uuid = { workspace = true }workspace-hack = { version = "0.1", path = "../workspace-hack" }[dev-dependencies]+jev = { path = "../jev", features = ["outbound"] }rootcause = { workspace = true }agent_fold = { path = "../folds/agent_fold" }agent_session = { path = "../agent_session", features = ["test-utils"] }@@ -67,4 +70,4 @@ opentelemetry = { workspace = true, features = ["trace"] }opentelemetry_sdk = { workspace = true, features = ["testing", "trace"] }tracing-opentelemetry = { workspace = true }tracing-subscriber = { workspace = true }-tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }+tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time", "test-util"] }diff --git a/crates/agent_inmem/src/domain/mod.rs b/crates/agent_inmem/src/domain/mod.rsindex d6d5137fc8..60c444d12a 100644--- a/crates/agent_inmem/src/domain/mod.rs+++ b/crates/agent_inmem/src/domain/mod.rs@@ -16,6 +16,8 @@ pub mod model_options;pub mod models;pub mod replay;pub mod session;+/// Which of the user's skills a turn loads on its own, and where they sit.+pub mod skill_routing;/// Whether one of Macro's own tools may run in this turn.pub mod tool_gate;pub mod tool_mode;diff --git a/crates/agent_inmem/src/domain/skill_routing.rs b/crates/agent_inmem/src/domain/skill_routing.rsnew file mode 100644index 0000000000..378de1061d--- /dev/null+++ b/crates/agent_inmem/src/domain/skill_routing.rs@@ -0,0 +1,164 @@+//! Loading the user's skills a turn needs: who has it, what a session has+//! loaded, and where loaded skills sit in the turn's context.++use std::collections::HashMap;+use std::sync::{Mutex, PoisonError};+use std::time::Duration;+use std::{future::Future, pin::Pin};++use agent::types::{ChatMessage, ChatMessageContent, Role};+use agent_session::domain::model::AgentSessionId;+use feature_flags::FeatureFlags;+use macro_user_id::user_id::MacroUserIdStr;+use skills::domain::selection::{LoadedSkill, render_loaded};+use tokio::time::Instant;+use uuid::Uuid;++#[cfg(test)]+mod eval;+#[cfg(test)]+mod test;++pub use crate::domain::entity_routing::AUTO_SKILLS;++/// Most skills one session keeps loaded; the oldest go first.+pub const SKILLS_PER_SESSION: usize = 8;++/// How long a session's skills outlive its last turn.+pub const SESSION_IDLE: Duration = Duration::from_secs(24 * 60 * 60);++/// Whether a turn loads skills on its own.+pub trait SkillRoutingPolicy: Send + Sync {+ /// Whether `owner`'s turns route skills; unavailable flags do not.+ fn routes<'a>(+ &'a self,+ owner: &'a MacroUserIdStr<'_>,+ ) -> Pin<Box<dyn Future<Output = bool> + Send + 'a>>;+}++/// Default when this deployment has no feature-flag provider.+pub struct NoSkillRouting;++impl SkillRoutingPolicy for NoSkillRouting {+ fn routes<'a>(+ &'a self,+ _: &'a MacroUserIdStr<'_>,+ ) -> Pin<Box<dyn Future<Output = bool> + Send + 'a>> {+ Box::pin(async { false })+ }+}++/// Routes skills for owners with [`AUTO_SKILLS`].+pub struct FlaggedSkillRouting<F> {+ flags: F,+}++impl<F: FeatureFlags> FlaggedSkillRouting<F> {+ /// Compose with a provider whose load has a bounded deadline.+ pub fn new(flags: F) -> Self {+ Self { flags }+ }+}++impl<F: FeatureFlags> SkillRoutingPolicy for FlaggedSkillRouting<F> {+ fn routes<'a>(+ &'a self,+ owner: &'a MacroUserIdStr<'_>,+ ) -> Pin<Box<dyn Future<Output = bool> + Send + 'a>> {+ Box::pin(async move {+ self.flags+ .load(owner)+ .await+ .inspect_err(|error| {+ tracing::warn!(?error, "feature flags unavailable; not routing skills");+ })+ .unwrap_or_default()+ .is_enabled(AUTO_SKILLS)+ })+ }+}++/// The skills each session has loaded, each with the request (the user+/// message, counted from 0) that loaded it, so a skill stays in effect without+/// being routed again and sits in the same place on every turn. Kept in+/// memory: after a restart a session routes again from its next message.+#[derive(Default)]+pub struct SessionSkills {+ sessions: Mutex<HashMap<AgentSessionId, Loaded>>,+}++struct Loaded {+ touched: Instant,+ skills: Vec<(usize, LoadedSkill)>,+}++impl SessionSkills {+ /// The skills `session` has loaded with their requests, oldest first.+ pub fn loaded(&self, session: AgentSessionId) -> Vec<(usize, LoadedSkill)> {+ self.sessions+ .lock()+ .unwrap_or_else(PoisonError::into_inner)+ .get(&session)+ .map(|loaded| loaded.skills.clone())+ .unwrap_or_default()+ }++ /// The ids of the skills `session` has loaded.+ pub fn loaded_ids(&self, session: AgentSessionId) -> Vec<Uuid> {+ self.loaded(session)+ .iter()+ .map(|(_, skill)| skill.id)+ .collect()+ }++ /// Record that `request` loaded `skills` and return everything `session`+ /// has loaded. Keeps the newest [`SKILLS_PER_SESSION`]; forgets sessions+ /// idle for [`SESSION_IDLE`].+ pub fn add(+ &self,+ session: AgentSessionId,+ request: usize,+ skills: Vec<LoadedSkill>,+ ) -> Vec<(usize, LoadedSkill)> {+ let now = Instant::now();+ let mut sessions = self.sessions.lock().unwrap_or_else(PoisonError::into_inner);+ sessions.retain(|_, loaded| now.duration_since(loaded.touched) < SESSION_IDLE);+ let loaded = sessions.entry(session).or_insert_with(|| Loaded {+ touched: now,+ skills: Vec::new(),+ });+ loaded.touched = now;+ for skill in skills {+ if !loaded.skills.iter().any(|(_, known)| known.id == skill.id) {+ loaded.skills.push((request, skill));+ }+ }+ let excess = loaded.skills.len().saturating_sub(SKILLS_PER_SESSION);+ loaded.skills.drain(..excess);+ loaded.skills.clone()+ }+}++/// Append each loaded skill to the user message that loaded it, as one+/// `<loaded_skills>` block per message. Only the model's copy of the context+/// changes; the session log keeps what the user wrote.+pub fn inject(messages: &mut [ChatMessage], loaded: &[(usize, LoadedSkill)]) {+ let requests = messages+ .iter_mut()+ .filter(|message| message.role == Role::User)+ .enumerate();+ for (request, message) in requests {+ let skills: Vec<LoadedSkill> = loaded+ .iter()+ .filter(|(at, _)| *at == request)+ .map(|(_, skill)| skill.clone())+ .collect();+ if skills.is_empty() {+ continue;+ }+ if let ChatMessageContent::Text(text) = &mut message.content {+ text.push_str("\n\n");+ text.push_str(&render_loaded(&skills));+ }+ }+}diff --git a/crates/agent_inmem/src/domain/skill_routing/eval.rs b/crates/agent_inmem/src/domain/skill_routing/eval.rsnew file mode 100644index 0000000000..d72ef8790c--- /dev/null+++ b/crates/agent_inmem/src/domain/skill_routing/eval.rs@@ -0,0 +1,344 @@+//! Routes evaluation prompts through the real Jev over a fixture set of user+//! skills and reports how often the expected skills load.+//!+//! ```text+//! doppler run --project agent-harness-service --config dev -- \+//! cargo test -p agent_inmem --lib route_evaluation -- --ignored --nocapture+//! ```++use std::collections::BTreeMap;+use std::sync::{Arc, Mutex};++use async_trait::async_trait;+use cognition::domain::{+ Cognition, DecisionRequest, DecisionResponse, GenerateObjectRequest, GenerateObjectResponse,+};+use jev::domain::{JevProvider as _, YesNoQuestion};+use macro_user_id::user_id::MacroUserIdStr;+use rootcause::Report;+use skills::domain::model::{SkillContent, SkillError, SkillMatchType, SkillSummary};+use skills::domain::ports::SkillService;+use skills::domain::selection::{SkillRequest, select_skills};+use tokio_util::sync::CancellationToken;+use uuid::Uuid;++/// A user's skills: name and description. One predates descriptions.+const SKILLS: &[(&str, Option<&str>)] = &[+ (+ "Release notes",+ Some(+ "Use when drafting release notes or a changelog for a product release; not internal status updates.",+ ),+ ),+ (+ "Weekly status update",+ Some(+ "Use when writing a weekly status or progress update for the team; not release notes.",+ ),+ ),+ (+ "Code review checklist",+ Some("Use when reviewing a pull request or code change; not writing new code."),+ ),+ (+ "Contract review",+ Some("Use when reviewing a contract, NDA or other legal agreement; not drafting emails."),+ ),+ (+ "Customer support reply",+ Some("Use when answering a customer's support question or ticket; not internal messages."),+ ),+ (+ "Sales follow-up email",+ Some(+ "Use when writing a follow-up email to a prospect after a sales call or demo; not support replies.",+ ),+ ),+ (+ "Meeting notes",+ Some(+ "Use when turning a meeting or call into notes with decisions and action items; not scheduling meetings.",+ ),+ ),+ (+ "Bug report",+ Some("Use when triaging or writing up a bug report; not fixing the bug."),+ ),+ (+ "Interview scorecard",+ Some("Use when evaluating a candidate after an interview; not scheduling interviews."),+ ),+ (+ "Blog post style",+ Some("Use when writing a post or article for the company blog; not social media posts."),+ ),+ (+ "Social post",+ Some("Use when writing a LinkedIn or X post; not blog articles."),+ ),+ ("Brand voice", None),+];++/// Each prompt and the skills it should load, by name.+const PROMPTS: &[(&str, &[&str])] = &[+ (+ "Draft release notes for v2.3 from the merged PRs",+ &["Release notes"],+ ),+ (+ "Write this week's status update for the platform team",+ &["Weekly status update"],+ ),+ (+ "Review PR 482 and leave comments",+ &["Code review checklist"],+ ),+ (+ "Can you check this NDA from Acme for anything unusual?",+ &["Contract review"],+ ),+ (+ "Reply to the customer asking why their export failed",+ &["Customer support reply"],+ ),+ (+ "Send a follow-up to Dana after today's demo",+ &["Sales follow-up email"],+ ),+ (+ "Turn the transcript of this morning's call into notes",+ &["Meeting notes"],+ ),+ ("Write up the login crash as a bug report", &["Bug report"]),+ (+ "Score yesterday's candidate for the backend role",+ &["Interview scorecard"],+ ),+ (+ "Write a blog post announcing the new API",+ &["Blog post style"],+ ),+ ("Draft a LinkedIn post about our launch", &["Social post"]),+ (+ "Write a blog post about the launch and a LinkedIn post to share it",+ &["Blog post style", "Social post"],+ ),+ (+ "Summarise the call with Acme and draft the follow-up email",+ &["Meeting notes", "Sales follow-up email"],+ ),+ ("Write it in our brand voice", &["Brand voice"]),+ (+ "Schedule a 30 minute interview with the candidate next week",+ &[],+ ),+ ("Fix the login crash", &[]),+ ("Move the launch doc into the Marketing folder", &[]),+ ("What did we decide about pricing last week?", &[]),+ ("What's 15% of 2,340?", &[]),+ ("Thanks, that's perfect!", &[]),+];++const RUNS: usize = 3;+const THRESHOLDS: [f32; 3] = [0.7, 0.8, 0.9];+const LOAD_LIMIT: usize = 2;++fn candidates() -> Vec<SkillSummary> {+ SKILLS+ .iter()+ .map(|(name, description)| SkillSummary {+ document_id: Uuid::new_v5(&Uuid::NAMESPACE_OID, name.as_bytes()),+ name: (*name).to_string(),+ description: description.map(str::to_string),+ updated_at: None,+ })+ .collect()+}++struct EvalSkills(Vec<SkillSummary>);++impl SkillService for EvalSkills {+ async fn read_skill(+ &self,+ _: &MacroUserIdStr<'_>,+ document_id: Uuid,+ ) -> Result<SkillContent, SkillError> {+ let skill = self+ .0+ .iter()+ .find(|skill| skill.document_id == document_id)+ .ok_or(SkillError::NotASkill)?;+ Ok(SkillContent {+ document_id,+ name: skill.name.clone(),+ content: String::new(),+ })+ }++ async fn search_skills(+ &self,+ _: &MacroUserIdStr<'_>,+ _: &str,+ _: SkillMatchType,+ ) -> Result<Vec<SkillSummary>, SkillError> {+ Ok(Vec::new())+ }++ async fn list_skills(&self, _: &MacroUserIdStr<'_>) -> Result<Vec<SkillSummary>, SkillError> {+ Ok(self.0.clone())+ }++ async fn list_routable_skills(+ &self,+ _: &MacroUserIdStr<'_>,+ ) -> Result<Vec<SkillSummary>, SkillError> {+ Ok(self.0.clone())+ }+}++/// The real Jev, keeping every score it gives.+struct RecordingJev {+ jev: jev::outbound::SystemOneJev,+ scores: Mutex<BTreeMap<String, f32>>,+}++#[async_trait]+impl Cognition for RecordingJev {+ async fn generate_object(+ &self,+ _: &MacroUserIdStr<'static>,+ _: GenerateObjectRequest,+ ) -> Result<GenerateObjectResponse, Report> {+ Err(rootcause::report!("the evaluation only classifies"))+ }++ async fn decide(+ &self,+ _: &MacroUserIdStr<'static>,+ request: DecisionRequest,+ ) -> Result<DecisionResponse, Report> {+ let mut keys = Vec::new();+ let mut questions = Vec::new();+ for (key, question) in request.questions {+ keys.push(key);+ questions.push(+ YesNoQuestion::try_from(question).map_err(|error| rootcause::report!("{error}"))?,+ );+ }+ let evaluation = self+ .jev+ .evaluate(&request.input, &questions)+ .await+ .map_err(|error| rootcause::report!("{error}"))?;+ let probabilities: BTreeMap<String, f32> = keys+ .into_iter()+ .zip(evaluation.probabilities)+ .map(|(key, probability)| (key, probability.get()))+ .collect();+ self.scores.lock().unwrap().extend(probabilities.clone());+ Ok(DecisionResponse { probabilities })+ }+}++#[tokio::test(flavor = "multi_thread")]+#[ignore = "calls TypeSafe's Jev; needs TYPESAFE_API_KEY"]+async fn route_evaluation() {+ let key = jev::outbound::TypesafeApiKey::new().expect("TYPESAFE_API_KEY is set");+ let jev = Arc::new(RecordingJev {+ jev: jev::outbound::SystemOneJev::typesafe(key.value().expect("TYPESAFE_API_KEY is set"))+ .unwrap(),+ scores: Mutex::new(BTreeMap::new()),+ });+ let cognition: Arc<dyn Cognition> = jev.clone();+ let skills = EvalSkills(candidates());+ let names: BTreeMap<String, String> = skills+ .0+ .iter()+ .map(|skill| (skill.document_id.to_string(), skill.name.clone()))+ .collect();+ let owner = MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap();++ let mut shipped_exact = 0usize;+ let mut exact = [0usize; THRESHOLDS.len()];+ let mut recalled = [0usize; THRESHOLDS.len()];+ let mut spurious = [0usize; THRESHOLDS.len()];+ let mut expected_total = 0usize;+ for (prompt, expected) in PROMPTS {+ for run in 0..RUNS {+ jev.scores.lock().unwrap().clear();+ let selection = select_skills(+ &skills,+ Some(&cognition),+ &owner,+ SkillRequest {+ latest: prompt,+ previous: None,+ },+ &[],+ &CancellationToken::new(),+ )+ .await;+ let loaded: Vec<&str> = selection+ .loaded+ .iter()+ .map(|skill| skill.name.as_str())+ .collect();+ shipped_exact += usize::from(same_set(&loaded, expected));+ let mut ranked: Vec<(String, f32)> = jev+ .scores+ .lock()+ .unwrap()+ .iter()+ .map(|(key, score)| (names[key].clone(), *score))+ .collect();+ ranked.sort_by(|a, b| b.1.total_cmp(&a.1));+ expected_total += expected.len();+ for (index, threshold) in THRESHOLDS.iter().enumerate() {+ let swept: Vec<&str> = ranked+ .iter()+ .filter(|(_, score)| score >= threshold)+ .take(LOAD_LIMIT)+ .map(|(name, _)| name.as_str())+ .collect();+ exact[index] += usize::from(same_set(&swept, expected));+ recalled[index] += expected.iter().filter(|name| swept.contains(name)).count();+ spurious[index] += usize::from(expected.is_empty() && !swept.is_empty());+ }+ if run == 0 {+ let top: Vec<String> = ranked+ .iter()+ .take(3)+ .map(|(name, score)| format!("{name} {score:.2}"))+ .collect();+ println!(+ "{prompt:<68} expected {expected:?} loaded {loaded:?} top [{}]",+ top.join(", ")+ );+ }+ }+ }+ let runs = PROMPTS.len() * RUNS;+ let none_runs = PROMPTS+ .iter()+ .filter(|(_, expected)| expected.is_empty())+ .count()+ * RUNS;+ println!(+ "\n{} prompts x {RUNS} runs over {} skills",+ PROMPTS.len(),+ SKILLS.len()+ );+ println!(+ "as shipped (0.8, or 0.95 without a description; at most 2): exact set {shipped_exact}/{runs}"+ );+ for (index, threshold) in THRESHOLDS.iter().enumerate() {+ println!(+ "at {threshold}: exact set {}/{runs}, recall {}/{expected_total}, loads on prompts needing none {}/{none_runs}",+ exact[index], recalled[index], spurious[index]+ );+ }+}++fn same_set(loaded: &[&str], expected: &[&str]) -> bool {+ loaded.len() == expected.len() && expected.iter().all(|name| loaded.contains(name))+}diff --git a/crates/agent_inmem/src/domain/skill_routing/test.rs b/crates/agent_inmem/src/domain/skill_routing/test.rsnew file mode 100644index 0000000000..7b700ed7c2--- /dev/null+++ b/crates/agent_inmem/src/domain/skill_routing/test.rs@@ -0,0 +1,137 @@+use super::*;+use agent::types::{ChatMessage, ChatMessageContent, Role};+use feature_flags::{FlagSnapshot, FlagValue, outbound::fake::FakeFeatureFlags};++fn skill(id: u128) -> LoadedSkill {+ LoadedSkill {+ id: Uuid::from_u128(id),+ name: format!("Skill {id}"),+ score: 0.9,+ content: format!("Instructions {id}."),+ }+}++fn ids(skills: &[(usize, LoadedSkill)]) -> Vec<(usize, u128)> {+ skills+ .iter()+ .map(|(turn, skill)| (*turn, skill.id.as_u128()))+ .collect()+}++fn message(role: Role, text: &str) -> ChatMessage {+ ChatMessage {+ content: ChatMessageContent::Text(text.to_owned()),+ role,+ attachments: None,+ }+}++fn text(message: &ChatMessage) -> &str {+ match &message.content {+ ChatMessageContent::Text(text) => text,+ ChatMessageContent::AssistantMessageParts(_) => panic!("not text"),+ }+}++#[tokio::test]+async fn only_flagged_owners_route_and_failures_do_not() {+ let owners: Vec<_> = ["enabled", "disabled", "failure"]+ .map(|name| MacroUserIdStr::try_from(format!("macro|{name}@example.com")).unwrap())+ .into();+ let mut flags = FakeFeatureFlags::default();+ flags.set(+ owners[0].clone(),+ Ok(FlagSnapshot::new([(+ AUTO_SKILLS.into(),+ FlagValue::Boolean(true),+ )])),+ );+ flags.set(+ owners[1].clone(),+ Ok(FlagSnapshot::new([(+ AUTO_SKILLS.into(),+ FlagValue::Boolean(false),+ )])),+ );+ flags.set(owners[2].clone(), Err("provider unavailable".into()));+ let policy = FlaggedSkillRouting::new(flags);++ assert!(policy.routes(&owners[0]).await);+ assert!(!policy.routes(&owners[1]).await);+ assert!(!policy.routes(&owners[2]).await);+ assert!(!NoSkillRouting.routes(&owners[0]).await);+}++#[test]+fn a_session_keeps_each_skill_with_the_request_that_loaded_it() {+ let sessions = SessionSkills::default();+ let session = AgentSessionId::new();++ assert!(sessions.loaded(session).is_empty());+ sessions.add(session, 0, vec![skill(1)]);+ sessions.add(session, 2, vec![skill(2), skill(1)]);++ assert_eq!(ids(&sessions.loaded(session)), [(0, 1), (2, 2)]);+ assert_eq!(+ sessions.loaded_ids(session),+ [Uuid::from_u128(1), Uuid::from_u128(2)]+ );+ assert!(sessions.loaded(AgentSessionId::new()).is_empty());+}++#[test]+fn a_session_keeps_its_newest_skills_past_the_limit() {+ let sessions = SessionSkills::default();+ let session = AgentSessionId::new();++ for id in 1..=(SKILLS_PER_SESSION as u128 + 2) {+ sessions.add(session, id as usize, vec![skill(id)]);+ }++ let kept = ids(&sessions.loaded(session));+ assert_eq!(kept.len(), SKILLS_PER_SESSION);+ assert_eq!(kept.first(), Some(&(3, 3)));+}++#[tokio::test(start_paused = true)]+async fn idle_sessions_are_forgotten() {+ let sessions = SessionSkills::default();+ let idle = AgentSessionId::new();+ sessions.add(idle, 0, vec![skill(1)]);++ tokio::time::advance(SESSION_IDLE + Duration::from_secs(1)).await;+ sessions.add(AgentSessionId::new(), 0, vec![skill(2)]);++ assert!(sessions.loaded(idle).is_empty());+}++#[test]+fn loaded_skills_follow_the_request_that_loaded_them_in_the_context() {+ let mut messages = vec![+ message(Role::User, "first"),+ message(Role::Assistant, "reply"),+ message(Role::User, "second"),+ message(Role::User, "third"),+ ];++ inject(+ &mut messages,+ &[(0, skill(1)), (2, skill(2)), (2, skill(3)), (9, skill(4))],+ );++ let first = text(&messages[0]);+ assert!(first.starts_with("first\n\n<loaded_skills>\n"));+ assert!(first.contains("Instructions 1."));+ assert_eq!(text(&messages[1]), "reply");+ assert_eq!(text(&messages[2]), "second");+ let third = text(&messages[3]);+ assert!(third.contains("Instructions 2.") && third.contains("Instructions 3."));+ assert!(!third.contains("Instructions 4."));+}++#[test]+fn nothing_loaded_leaves_the_context_unchanged() {+ let mut messages = vec![message(Role::User, "only")];+ inject(&mut messages, &[]);+ assert_eq!(text(&messages[0]), "only");+}diff --git a/crates/agent_inmem/src/lib.rs b/crates/agent_inmem/src/lib.rsindex 02c580d194..5e68a543a2 100644--- a/crates/agent_inmem/src/lib.rs+++ b/crates/agent_inmem/src/lib.rs@@ -17,6 +17,9 @@//! - [`outbound::manager::InMemAgentManager`] provisions per-session agent//! tasks and hands the harness the [`agent_runtime_protocol`] transport it//! expects from any container manager.+// The skill service's listing future, laid out inside a turn, needs more than+// the default query depth with production adapters.+#![recursion_limit = "256"]#![deny(missing_docs)]pub mod domain;diff --git a/crates/agent_inmem/src/rig_engine.rs b/crates/agent_inmem/src/rig_engine.rsindex 7edf50bd72..d3bf0bfc33 100644--- a/crates/agent_inmem/src/rig_engine.rs+++ b/crates/agent_inmem/src/rig_engine.rs@@ -20,6 +20,7 @@//! is why the in-memory runtime is the one provider that needs no wire format//! for them. See [`system_prompt`] for how the sections are ordered.+use std::pin::Pin;use std::sync::Arc;use agent::{AgentError, AgentLoop, ReadToolResult, StreamPart, SystemPrompt, ToolResultLimit};@@ -35,11 +36,13 @@ use memory::outbound::pg_memory_repo::PgMemoryRepo;use model_owner::Owner;use sqlx::PgPool;use tokio::sync::mpsc;+use tokio_util::sync::CancellationToken;use tracing::Instrument as _;use crate::domain::auto_model::{AutoModelSelector, DefaultAutoModel, JevAutoModel};use crate::domain::engine::{AgentIdentity, ReplyDelivery, TurnEngine, TurnRequest};use crate::domain::entity_routing::{EntityRoutingPolicy, NoEntityRouting};+use crate::domain::skill_routing::{NoSkillRouting, SessionSkills, SkillRoutingPolicy};use crate::domain::tool_gate::{NativeToolGate, NativeToolVerdict, UngatedNativeTools};use crate::domain::tool_mode::{StandardTools, ToolMode, ToolModeSelector};use crate::inbound::ask_user::{AskUser, AskUserContext};@@ -81,6 +84,8 @@ pub struct RigTurnEngine {code_mode_tools: Arc<NativeTools>,tool_mode: Arc<dyn ToolModeSelector>,auto_model: Arc<dyn AutoModelSelector>,+ skill_routing: Arc<dyn SkillRoutingPolicy>,+ session_skills: Arc<SessionSkills>,entity_routing: Arc<dyn EntityRoutingPolicy>,tool_context: ToolServiceContext,gate: Arc<dyn NativeToolGate>,@@ -107,6 +112,8 @@ impl RigTurnEngine {Some(cognition) => Arc::new(JevAutoModel::new(Arc::clone(cognition))),None => Arc::new(DefaultAutoModel),},+ skill_routing: Arc::new(NoSkillRouting),+ session_skills: Arc::new(SessionSkills::default()),entity_routing: Arc::new(NoEntityRouting),tool_context,gate: Arc::new(UngatedNativeTools),@@ -127,6 +134,13 @@ impl RigTurnEngine {self}+ /// Decide per turn whether the owner's turns load their skills on their own.+ #[must_use]+ pub fn with_skill_routing(mut self, policy: Arc<dyn SkillRoutingPolicy>) -> Self {+ self.skill_routing = policy;+ self+ }+/// Decide per turn whether the owner's code-mode turns route SDK entities.#[must_use]pub fn with_entity_routing(mut self, policy: Arc<dyn EntityRoutingPolicy>) -> Self {@@ -344,6 +358,8 @@ impl TurnEngine for RigTurnEngine {let code_mode_tools = Arc::clone(&self.code_mode_tools);let tool_mode = Arc::clone(&self.tool_mode);let auto_model = Arc::clone(&self.auto_model);+ let skill_routing = Arc::clone(&self.skill_routing);+ let session_skills = Arc::clone(&self.session_skills);let entity_routing = Arc::clone(&self.entity_routing);let tool_context = self.tool_context.clone();let gate = Arc::clone(&self.gate);@@ -355,8 +371,9 @@ impl TurnEngine for RigTurnEngine {return;};request.model = model;- let (selected, routes) = tokio::join!(+ let (selected, routes, entities_routed) = tokio::join!(select_tool_mode(tool_mode.as_ref(), &request),+ routes_skills(skill_routing.as_ref(), &request),routes_entities(entity_routing.as_ref(), &request),);let Some(selected) = selected else {@@ -370,10 +387,15 @@ impl TurnEngine for RigTurnEngine {// The product toolset makes this future large. Keep its state// on the heap when adding the panic boundary, including in// unoptimized local builds with Tokio's default worker stack.+ let skills = TurnRouting {+ routes,+ sessions: &session_skills,+ entities: entities_routed,+ };let turn = Box::pin(drive_turn(&memory,&native_tools,- routes,+ skills,tool_context,gate,request,@@ -432,6 +454,15 @@ async fn select_auto_model(}}+// Only conversation turns load skills; summaries read no instructions.+async fn routes_skills(policy: &dyn SkillRoutingPolicy, request: &TurnRequest) -> bool {+ let Owner::User(owner) = &request.owner else {+ return false;+ };+ request.purpose == crate::domain::engine::TurnPurpose::Conversation+ && policy.routes(owner).await+}+// Only a user's conversation turns route SDK entities; summaries read none.async fn routes_entities(policy: &dyn EntityRoutingPolicy, request: &TurnRequest) -> bool {let Owner::User(owner) = &request.owner else {@@ -441,6 +472,33 @@ async fn routes_entities(policy: &dyn EntityRoutingPolicy, request: &TurnRequest&& policy.routes(owner).await}+/// What a turn loads on its own: the user's skills (and what its session has+/// loaded already), and the SDK areas its request needs.+struct TurnRouting<'a> {+ routes: bool,+ sessions: &'a SessionSkills,+ entities: bool,+}++/// Route the turn's request to the user's skills. Boxed: the skill service's+/// listing future is deep enough to overflow the turn's own future type.+fn select_skills<'a>(+ context: &'a ToolServiceContext,+ owner: &'a MacroUserIdStr<'static>,+ request: skills::domain::selection::SkillRequest<'a>,+ already_loaded: &'a [uuid::Uuid],+ cancel: &'a CancellationToken,+) -> Pin<Box<dyn Future<Output = skills::domain::selection::SkillSelection> + Send + 'a>> {+ Box::pin(skills::domain::selection::select_skills(+ context.skill_tool_context.service.as_ref(),+ context.cognition_tool_context.service.as_ref(),+ owner,+ request,+ already_loaded,+ cancel,+ ))+}+// A failed/missing code-mode MCP connection must never leave a turn with only the// small direct set. Summaries neither evaluate flags nor advertise tools.async fn select_tool_mode(@@ -470,7 +528,7 @@ async fn select_tool_mode(async fn drive_turn(memory: &MemoryServiceImpl<PgMemoryRepo>,native_tools: &NativeTools,- routes_entities: bool,+ skills: TurnRouting<'_>,base_context: ToolServiceContext,gate: Arc<dyn NativeToolGate>,request: TurnRequest,@@ -571,22 +629,23 @@ async fn drive_turn(// Chat's tools with the session's prompt: the user tools (`SendEmail`,// `CreateCalendarEvent`) defer to the user, and this runtime finishes// them in the turn through `reviewer`.- let (system_prompt, toolset, deferred) = if summarizing {+ let (system_prompt, toolset, deferred, loaded_skills) = if summarizing {(SystemPrompt::from(instructions.unwrap_or_default()),Arc::new(AsyncToolCollection::<InMemToolContext>::new()),Arc::from(Vec::new()),+ Vec::new(),)} else {- let requested = messages+ let user_messages: Vec<String> = messages.iter()- .rev()- .find(|message| message.role == agent::types::Role::User)- .and_then(|message| message.content.user_message_text())- .unwrap_or_default();+ .filter(|message| message.role == agent::types::Role::User)+ .filter_map(|message| message.content.user_message_text())+ .collect();+ let requested = user_messages.last().cloned().unwrap_or_default();// Routed turns leave area guidance out of the prompt; the entities the// request needs bring theirs, with their indexes, in the turn's part.- let routed = native_tools.code_mode && routes_entities;+ let routed = native_tools.code_mode && skills.entities;let docs = async {if native_tools.code_mode {agent_code_mode::domain::select_documentation(@@ -605,7 +664,32 @@ async fn drive_turn(String::new()}};- let (user_memory, sdk_docs) = tokio::join!(fetch_user_memory(memory, &owner), docs);+ let loaded_skills = async {+ if !skills.routes {+ return Vec::new();+ }+ let selection = select_skills(+ &base_context,+ &owner,+ skills::domain::selection::SkillRequest {+ latest: &requested,+ previous: user_messages+ .len()+ .checked_sub(2)+ .map(|index| user_messages[index].as_str()),+ },+ &skills.sessions.loaded_ids(session_id),+ &cancel,+ )+ .await;+ skills.sessions.add(+ session_id,+ user_messages.len().saturating_sub(1),+ selection.loaded,+ )+ };+ let (user_memory, sdk_docs, loaded_skills) =+ tokio::join!(fetch_user_memory(memory, &owner), docs, loaded_skills);let prompt = system_prompt(if routed {&native_tools.routed_prompt@@ -623,6 +707,7 @@ async fn drive_turn(prompt,native_tools.for_turn(user_input.is_some()),Arc::clone(&native_tools.deferred),+ loaded_skills,)};// Carry the feature on the context so tool-spawned subagents attribute to it.@@ -753,6 +838,10 @@ async fn drive_turn(}}));+ // Loaded skills ride with the request that loaded them, in the model's copy+ // of the conversation only.+ let mut messages = messages;+ crate::domain::skill_routing::inject(&mut messages, &loaded_skills);let rig_messages = agent::to_rig_messages_limited(&messages, &tool_results);let result = async {let mut stream = session.send_message(rig_messages).await?;diff --git a/crates/documents/src/domain.rs b/crates/documents/src/domain.rsindex 8908b62b3f..9de61f558a 100644--- a/crates/documents/src/domain.rs+++ b/crates/documents/src/domain.rs@@ -41,6 +41,8 @@ pub mod notion_markdown;#[cfg(feature = "axum")]pub mod permission_token;pub mod response;+/// A skill's one-line routing description.+pub mod skill_description;/// Permission-scoped spreadsheet inspection, calculation, and mutation.#[cfg(feature = "ai_tools")]diff --git a/crates/documents/src/domain/models.rs b/crates/documents/src/domain/models.rsindex f28fcf75f4..36366bcf4e 100644--- a/crates/documents/src/domain/models.rs+++ b/crates/documents/src/domain/models.rs@@ -663,12 +663,36 @@ pub struct CreateSnippetResponse {pub struct CreateSkillRequest {/// The name of the skill.pub skill_name: String,+ /// When to use the skill, in one line starting "Use when", e.g. "Use when+ /// drafting release notes; not changelog entries". Agents choose skills+ /// for a request by it.+ pub description: String,/// Markdown source text. Defaults to an empty skill document.pub markdown: Option<String>,/// Optional project ID to associate the skill with.pub project_id: Option<uuid::Uuid>,}+/// A skill's routing description.+#[derive(serde::Serialize, serde::Deserialize, Debug)]+#[cfg_attr(feature = "axum", derive(utoipa::ToSchema))]+#[serde(rename_all = "camelCase")]+pub struct SkillDescriptionBody {+ /// When to use the skill, in one line starting "Use when". Absent for a+ /// skill created before descriptions existed.+ pub description: Option<String>,+}++/// Request body for setting a skill's routing description.+#[derive(serde::Serialize, serde::Deserialize, Debug)]+#[cfg_attr(feature = "axum", derive(utoipa::ToSchema))]+#[serde(rename_all = "camelCase")]+pub struct SetSkillDescriptionRequest {+ /// When to use the skill, in one line starting "Use when", at most 300+ /// characters.+ pub description: String,+}+/// Response for creating a skill.#[derive(serde::Serialize, serde::Deserialize, Debug)]#[cfg_attr(feature = "axum", derive(utoipa::ToSchema))]diff --git a/crates/documents/src/domain/ports.rs b/crates/documents/src/domain/ports.rsindex a46d0d4d1f..af6da28949 100644--- a/crates/documents/src/domain/ports.rs+++ b/crates/documents/src/domain/ports.rs@@ -11,6 +11,7 @@ pub mod sync;#[cfg(test)]mod test;+use std::collections::HashMap;use std::future::Future;use entity_access::domain::models::{@@ -32,6 +33,7 @@ use super::events::InteractionReason;use super::response::{CreateDocumentResponseData, DocumentResponse, GetDocumentResponseData, LocationResponseV3,};+use super::skill_description::SkillDescription;use model::sync_service::SyncServiceVersionID;@@ -283,6 +285,20 @@ pub trait DocumentRepo: Send + Sync + 'static {command: AuthorizedTeamShareCommand,) -> impl Future<Output = Result<DocumentTeamShare, DocumentError>> + Send;+ /// The stored descriptions of `document_ids`, by document id. Skills with+ /// no description are left out.+ fn get_skill_descriptions(+ &self,+ document_ids: &[String],+ ) -> impl Future<Output = Result<HashMap<String, SkillDescription>, Self::Err>> + Send;++ /// Store a skill document's description, replacing any earlier one.+ fn set_skill_description(+ &self,+ document_id: &str,+ description: &SkillDescription,+ ) -> impl Future<Output = Result<(), Self::Err>> + Send;+/// Get document metadata at a specific version ID.fn get_document_metadata_at_version(&self,@@ -689,6 +705,28 @@ pub trait DocumentService: Send + Sync + 'static {entity_access_receipt: EntityAccessReceipt<EditAccessLevel>,share: bool,) -> impl Future<Output = Result<DocumentTeamShareResponse, DocumentError>> + Send;++ /// Set when to use a skill the caller can edit. Fails with+ /// [`DocumentError::BadRequest`] when the document is not a skill.+ fn set_skill_description(+ &self,+ entity_access_receipt: EntityAccessReceipt<EditAccessLevel>,+ description: SkillDescription,+ ) -> impl Future<Output = Result<(), DocumentError>> + Send;++ /// Describe a skill the caller has just created, and so owns.+ fn describe_new_skill(+ &self,+ document_id: &str,+ description: SkillDescription,+ ) -> impl Future<Output = Result<(), DocumentError>> + Send;++ /// The descriptions of skills the caller is already known to see, by+ /// document id. Skills with no description are left out.+ fn skill_descriptions(+ &self,+ document_ids: &[String],+ ) -> impl Future<Output = Result<HashMap<String, SkillDescription>, DocumentError>> + Send;}/// Shared editing-session timestamps, independent of document synchronization.diff --git a/crates/documents/src/domain/service.rs b/crates/documents/src/domain/service.rsindex d5139b14c4..97ae10fffa 100644--- a/crates/documents/src/domain/service.rs+++ b/crates/documents/src/domain/service.rs@@ -80,6 +80,7 @@ use super::response::{CreateDocumentResponseData, DocumentMetadataWithContent, DocumentResponse,DocumentResponseMetadataWithContent, GetDocumentResponseData, LocationResponseV3,};+use super::skill_description::SkillDescription;/// The concrete document service implementation.pub struct DocumentServiceImpl<@@ -2339,6 +2340,52 @@ impl<Ok(state.into())}+ #[tracing::instrument(err, skip(self, entity_access_receipt, description))]+ async fn set_skill_description(+ &self,+ entity_access_receipt: EntityAccessReceipt<EditAccessLevel>,+ description: SkillDescription,+ ) -> Result<(), DocumentError> {+ let document_id = &entity_access_receipt.entity().entity_id;+ let metadata = self+ .repo+ .get_document_metadata(document_id)+ .await+ .map_err(|e| DocumentError::Internal(e.into()))?;+ if metadata.sub_type != Some(DocumentSubType::Skill) {+ return Err(DocumentError::BadRequest(+ "only a skill has a description".to_string(),+ ));+ }+ self.repo+ .set_skill_description(document_id, &description)+ .await+ .map_err(|e| DocumentError::Internal(e.into()))+ }++ #[tracing::instrument(err, skip(self, description))]+ async fn describe_new_skill(+ &self,+ document_id: &str,+ description: SkillDescription,+ ) -> Result<(), DocumentError> {+ self.repo+ .set_skill_description(document_id, &description)+ .await+ .map_err(|e| DocumentError::Internal(e.into()))+ }++ #[tracing::instrument(err, skip(self, document_ids), fields(skills = document_ids.len()))]+ async fn skill_descriptions(+ &self,+ document_ids: &[String],+ ) -> Result<std::collections::HashMap<String, SkillDescription>, DocumentError> {+ self.repo+ .get_skill_descriptions(document_ids)+ .await+ .map_err(|e| DocumentError::Internal(e.into()))+ }+#[tracing::instrument(err, skip(self, entity_access_receipt))]async fn set_team_share(&self,diff --git a/crates/documents/src/domain/skill_description.rs b/crates/documents/src/domain/skill_description.rsnew file mode 100644index 0000000000..68e9261155--- /dev/null+++ b/crates/documents/src/domain/skill_description.rs@@ -0,0 +1,71 @@+//! A skill's routing description: one line saying when to use the skill.++#[cfg(test)]+mod test;++/// The longest description, in characters. The database enforces it too.+pub const MAX_CHARS: usize = 300;++const OPENING: &str = "use when ";++/// When to use a skill, in one line that opens "Use when" (and ideally says+/// "; not …" too). Agents choose skills for a request by this sentence.+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]+#[serde(transparent)]+pub struct SkillDescription(String);++/// Why a description was rejected; the message is shown to the user.+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]+pub enum SkillDescriptionError {+ /// Nothing but whitespace.+ #[error("Describe when to use the skill, starting \"Use when\".")]+ Empty,+ /// More than one line.+ #[error("Keep the description to one line.")]+ MultipleLines,+ /// Longer than [`MAX_CHARS`].+ #[error("Keep the description to {MAX_CHARS} characters or fewer.")]+ TooLong,+ /// Does not open with "Use when".+ #[error(+ "Start the description with \"Use when\", e.g. \"Use when drafting release notes; not changelogs\"."+ )]+ MissingOpening,+}++impl SkillDescription {+ /// Validate a description the user wrote, trimming surrounding space.+ pub fn parse(text: &str) -> Result<Self, SkillDescriptionError> {+ let text = text.trim();+ if text.is_empty() {+ return Err(SkillDescriptionError::Empty);+ }+ if text.contains(['\n', '\r']) {+ return Err(SkillDescriptionError::MultipleLines);+ }+ if text.chars().count() > MAX_CHARS {+ return Err(SkillDescriptionError::TooLong);+ }+ let opening = text.get(..OPENING.len()).unwrap_or_default();+ if !opening.eq_ignore_ascii_case(OPENING) {+ return Err(SkillDescriptionError::MissingOpening);+ }+ Ok(Self(text.to_owned()))+ }++ /// A description already validated when it was stored.+ pub fn from_stored(text: String) -> Self {+ Self(text)+ }++ /// The description text.+ pub fn as_str(&self) -> &str {+ &self.0+ }+}++impl From<SkillDescriptionError> for crate::domain::models::DocumentError {+ fn from(error: SkillDescriptionError) -> Self {+ Self::BadRequest(error.to_string())+ }+}diff --git a/crates/documents/src/domain/skill_description/test.rs b/crates/documents/src/domain/skill_description/test.rsnew file mode 100644index 0000000000..f50cb5e888--- /dev/null+++ b/crates/documents/src/domain/skill_description/test.rs@@ -0,0 +1,40 @@+use super::*;++#[test]+fn a_one_line_use_when_sentence_is_a_description() {+ let description =+ SkillDescription::parse(" Use when drafting release notes; not changelog entries. ")+ .unwrap();+ assert_eq!(+ description.as_str(),+ "Use when drafting release notes; not changelog entries."+ );+}++#[test]+fn the_use_when_opening_is_case_insensitive() {+ assert!(SkillDescription::parse("use when triaging bugs").is_ok());+}++#[test]+fn blank_multi_line_long_or_unprefixed_descriptions_are_rejected() {+ for invalid in [+ "",+ " ",+ "Use when one thing\nand another",+ "Drafts release notes",+ &format!("Use when {}", "x".repeat(300)),+ ] {+ assert!(+ SkillDescription::parse(invalid).is_err(),+ "accepted {invalid:?}"+ );+ }+}++#[test]+fn the_longest_description_fits_exactly() {+ let longest = format!("Use when {}", "x".repeat(MAX_CHARS - "Use when ".len()));+ assert_eq!(longest.chars().count(), MAX_CHARS);+ assert!(SkillDescription::parse(&longest).is_ok());+}diff --git a/crates/documents/src/inbound/axum_router.rs b/crates/documents/src/inbound/axum_router.rsindex bcbfebe65d..fe19e21ec2 100644--- a/crates/documents/src/inbound/axum_router.rs+++ b/crates/documents/src/inbound/axum_router.rs@@ -11,6 +11,7 @@//! - `POST /github_prs/tasks` — get the tasks linked to each of a batch of GitHub pull requests//! - `GET /{document_id}/short_id` — get document short ID//! - `GET`/`PUT /{document_id}/team_share` — get/set the document's team-share state+//! - `GET`/`PUT /{document_id}/skill_description` — get/set when to use a skill//! - `POST /create_markdown` — create and initialize a markdown document//! - `POST /create_snippet` — create and initialize a snippet document//! - `POST /create_skill` — create and initialize a skill document@@ -46,6 +47,7 @@ pub mod get_short_id;pub mod get_text;pub mod put_interaction;pub mod put_snapshot;+pub mod skill_description;pub mod sync_content_updated;pub mod system_skills;pub mod task_duplicates;@@ -94,6 +96,7 @@ use self::{get_location::get_location_v3_handler,get_short_id::get_short_id_handler,put_snapshot::put_snapshot_handler,+ skill_description::{get_skill_description_handler, set_skill_description_handler},system_skills::get_system_skills_handler,task_duplicates::{delete_this_duplicate_task_handler, dismiss_task_duplicates_handler,@@ -309,6 +312,11 @@ where"/{document_id}/team_share",axum::routing::get(get_team_share_handler::<T, Svc, Auth>).put(set_team_share_handler::<T, Svc, Auth>),+ )+ .route(+ "/{document_id}/skill_description",+ axum::routing::get(get_skill_description_handler::<T, Svc, Auth>)+ .put(set_skill_description_handler::<T, Svc, Auth>),);#[cfg(feature = "ai_tools")]diff --git a/crates/documents/src/inbound/axum_router/create_skill.rs b/crates/documents/src/inbound/axum_router/create_skill.rsindex c53ca40e92..0348b0e745 100644--- a/crates/documents/src/inbound/axum_router/create_skill.rs+++ b/crates/documents/src/inbound/axum_router/create_skill.rs@@ -12,9 +12,10 @@ use crate::domain::create::{MarkdownSubtype, NewDocumentMetadata, NewMarkdownTexuse crate::domain::models::{CreateSkillRequest, CreateSkillResponse, DocumentError};use crate::domain::ports::DocumentService;use crate::domain::ports::create::DocumentCreationService;+use crate::domain::skill_description::SkillDescription;-/// Creates a skill document with initialized markdown content in one-/// backend-owned lifecycle. Skills are markdown documents containing+/// Creates a skill document with initialized markdown content and its+/// routing description in one backend-owned lifecycle. Skills are markdown documents containing/// instructions that AI reads and follows when the skill is referenced in an/// AI input.#[utoipa::path(@@ -24,7 +25,7 @@ use crate::domain::ports::create::DocumentCreationService;request_body = CreateSkillRequest,responses((status = 200, body = inline(CreateSkillResponse)),- (status = 400, body = model_error_response::ErrorResponse),+ (status = 400, description = "The description is blank, longer than one line or 300 characters, or does not start \"Use when\"", body = model_error_response::ErrorResponse),(status = 401, body = model_error_response::ErrorResponse),(status = 500, body = model_error_response::ErrorResponse),)@@ -40,6 +41,8 @@ pub async fn create_skill_handler<project: ProjectBodyAccessLevelExtractorV2<EditAccessLevel, CreateSkillRequest, Svc, Auth>,) -> Result<Json<CreateSkillResponse>, DocumentError> {let req = project.into_inner();+ // Validate before creating, so a bad description creates nothing.+ let description = SkillDescription::parse(&req.description)?;let mut metadata = NewDocumentMetadata::builder(req.skill_name);if let Some(project_id) = req.project_id {@@ -58,7 +61,11 @@ pub async fn create_skill_handler<).await?;- Ok(Json(CreateSkillResponse {- document_id: created.document_id().to_string(),- }))+ let document_id = created.document_id().to_string();+ state+ .service+ .describe_new_skill(&document_id, description)+ .await?;++ Ok(Json(CreateSkillResponse { document_id }))}diff --git a/crates/documents/src/inbound/axum_router/skill_description.rs b/crates/documents/src/inbound/axum_router/skill_description.rsnew file mode 100644index 0000000000..8037625a93--- /dev/null+++ b/crates/documents/src/inbound/axum_router/skill_description.rs@@ -0,0 +1,90 @@+//! Handlers for `GET`/`PUT /documents/{document_id}/skill_description`.++use axum::{Json, extract::State};+use entity_access::domain::ports::EntityAccessService;+use entity_access::inbound::axum_extractors::DocumentAccessExtractor;+use macro_authorization::MacroAuthorizationService;+use models_permissions::share_permission::access_level::{EditAccessLevel, ViewAccessLevel};++use super::DocumentRouterState;+use crate::domain::models::{DocumentError, SetSkillDescriptionRequest, SkillDescriptionBody};+use crate::domain::ports::DocumentService;+use crate::domain::skill_description::SkillDescription;++/// Gets when to use a skill. `description` is absent for a skill created+/// before descriptions existed.+#[utoipa::path(+ tag = "document",+ get,+ path = "/documents/{document_id}/skill_description",+ operation_id = "get_skill_description",+ params(+ ("document_id" = String, Path, description = "Skill document ID")+ ),+ responses(+ (status = 200, body = SkillDescriptionBody),+ (status = 401, body = model_error_response::ErrorResponse),+ (status = 404, body = model_error_response::ErrorResponse),+ (status = 500, body = model_error_response::ErrorResponse),+ )+)]+#[tracing::instrument(skip(state, access), err)]+pub async fn get_skill_description_handler<+ T: DocumentService,+ Svc: EntityAccessService,+ Auth: MacroAuthorizationService,+>(+ State(state): State<DocumentRouterState<T, Svc, Auth>>,+ access: DocumentAccessExtractor<ViewAccessLevel, Svc, Auth>,+) -> Result<Json<SkillDescriptionBody>, DocumentError> {+ let document_id = access.entity_access_receipt.entity().entity_id.clone();+ let mut descriptions = state+ .service+ .skill_descriptions(std::slice::from_ref(&document_id))+ .await?;+ Ok(Json(SkillDescriptionBody {+ description: descriptions+ .remove(&document_id)+ .map(|description| description.as_str().to_owned()),+ }))+}++/// Sets when to use a skill: one line starting "Use when", at most 300+/// characters. Agents choose skills for a request by it.+#[utoipa::path(+ tag = "document",+ put,+ path = "/documents/{document_id}/skill_description",+ operation_id = "set_skill_description",+ params(+ ("document_id" = String, Path, description = "Skill document ID")+ ),+ request_body = SetSkillDescriptionRequest,+ responses(+ (status = 200, body = SkillDescriptionBody),+ (status = 400, description = "The document is not a skill, or the description is invalid", body = model_error_response::ErrorResponse),+ (status = 401, body = model_error_response::ErrorResponse),+ (status = 404, body = model_error_response::ErrorResponse),+ (status = 500, body = model_error_response::ErrorResponse),+ )+)]+#[tracing::instrument(skip(state, access, request), err)]+pub async fn set_skill_description_handler<+ T: DocumentService,+ Svc: EntityAccessService,+ Auth: MacroAuthorizationService,+>(+ State(state): State<DocumentRouterState<T, Svc, Auth>>,+ access: DocumentAccessExtractor<EditAccessLevel, Svc, Auth>,+ Json(request): Json<SetSkillDescriptionRequest>,+) -> Result<Json<SkillDescriptionBody>, DocumentError> {+ let description = SkillDescription::parse(&request.description)?;+ let stored = description.as_str().to_owned();+ state+ .service+ .set_skill_description(access.entity_access_receipt, description)+ .await?;+ Ok(Json(SkillDescriptionBody {+ description: Some(stored),+ }))+}diff --git a/crates/documents/src/inbound/axum_router/tests.rs b/crates/documents/src/inbound/axum_router/tests.rsindex ef3c466647..9b4a9b6b11 100644--- a/crates/documents/src/inbound/axum_router/tests.rs+++ b/crates/documents/src/inbound/axum_router/tests.rs@@ -495,6 +495,34 @@ impl DocumentService for FakeDocumentService {) -> Result<DocumentTeamShareResponse, DocumentError> {panic!("unexpected set_team_share call")}++ async fn set_skill_description(+ &self,+ _entity_access_receipt: entity_access::domain::models::EntityAccessReceipt<+ models_permissions::share_permission::access_level::EditAccessLevel,+ >,+ _description: crate::domain::skill_description::SkillDescription,+ ) -> Result<(), DocumentError> {+ panic!("unexpected set_skill_description call")+ }++ async fn describe_new_skill(+ &self,+ _document_id: &str,+ _description: crate::domain::skill_description::SkillDescription,+ ) -> Result<(), DocumentError> {+ Ok(())+ }++ async fn skill_descriptions(+ &self,+ _document_ids: &[String],+ ) -> Result<+ std::collections::HashMap<String, crate::domain::skill_description::SkillDescription>,+ DocumentError,+ > {+ Ok(std::collections::HashMap::new())+ }}impl DocumentContentEventService for FakeDocumentService {@@ -1778,3 +1806,23 @@ async fn canvas_creation_requires_project_edit_access_before_metadata_creation()EntityType::Project);}++#[tokio::test]+async fn a_skill_without_a_use_when_description_is_rejected_before_it_is_created() {+ for description in ["", "Drafts release notes", "Use when one\nand two"] {+ let (router, document_service, _access_service, _authorization_service) = test_router();+ let request =+ with_jwt(Request::post("/create_skill").header("content-type", "application/json"))+ .body(Body::from(+ json!({ "skillName": "Release notes", "description": description }).to_string(),+ ))+ .expect("request should build");++ assert_eq!(+ send_status(&router, request).await,+ StatusCode::BAD_REQUEST,+ "{description:?}"+ );+ assert!(document_service.create_calls().is_empty());+ }+}diff --git a/crates/documents/src/inbound/toolset/create_skill.rs b/crates/documents/src/inbound/toolset/create_skill.rsindex f87ad4bc46..1ab874a85b 100644--- a/crates/documents/src/inbound/toolset/create_skill.rs+++ b/crates/documents/src/inbound/toolset/create_skill.rs@@ -15,6 +15,7 @@ use crate::domain::models::DocumentError;use crate::domain::ports::{DocumentService, create::DocumentCreationService, editing::EditingWorkerService,};+use crate::domain::skill_description::SkillDescription;/// The created skill.#[derive(Debug, Serialize, JsonSchema)]@@ -28,12 +29,17 @@ pub struct CreateSkillResponse {#[serde(rename_all = "camelCase")]#[schemars(title = "CreateSkill",- description = "Create a skill: a markdown document of reusable instructions that AI reads and follows when the skill is referenced, as Compose Skill in the app does. Write the instructions as the markdown body. Edit an existing skill with EditDocument; find skills with ListSkills or SearchSkills."+ description = "Create a skill: a markdown document of reusable instructions that AI reads and follows when the skill is referenced or a request needs it, as Compose Skill in the app does. Write the instructions as the markdown body, and say in description when to use it. Edit an existing skill with EditDocument; find skills with ListSkills or SearchSkills.")]pub struct CreateSkill {#[schemars(description = "The skill's name.")]pub skill_name: String,+ #[schemars(+ description = "When to use the skill, in one line starting \"Use when\", at most 300 characters, e.g. \"Use when drafting release notes; not changelog entries\". Agents load the skill for requests this describes."+ )]+ pub description: String,+#[schemars(description = "The skill's instructions, in markdown.")]pub markdown: String,@@ -82,6 +88,11 @@ whereinternal_error: anyhow::anyhow!("empty skill name"),});}+ let description =+ SkillDescription::parse(&self.description).map_err(|error| ToolCallError {+ description: error.to_string(),+ internal_error: error.into(),+ })?;// Mirrors the create_skill route's project body extractor.if let Some(project_id) = self.project_id {service_context@@ -117,6 +128,11 @@ where).await.map_err(failed_to_create_skill)?;+ service_context+ .service+ .describe_new_skill(created.document_id(), description)+ .await+ .map_err(failed_to_create_skill)?;let document_id =Uuid::parse_str(created.document_id()).map_err(|error| ToolCallError {description: "the skill was created but returned an invalid id".to_string(),diff --git a/crates/documents/src/inbound/toolset/edit_document/test.rs b/crates/documents/src/inbound/toolset/edit_document/test.rsindex dae33fda6d..d7933c806b 100644--- a/crates/documents/src/inbound/toolset/edit_document/test.rs+++ b/crates/documents/src/inbound/toolset/edit_document/test.rs@@ -330,6 +330,34 @@ impl DocumentService for FakeDocumentService {) -> Result<DocumentTeamShareResponse, DocumentError> {panic!("unexpected set_team_share call")}++ async fn set_skill_description(+ &self,+ _entity_access_receipt: entity_access::domain::models::EntityAccessReceipt<+ models_permissions::share_permission::access_level::EditAccessLevel,+ >,+ _description: crate::domain::skill_description::SkillDescription,+ ) -> Result<(), DocumentError> {+ panic!("unexpected set_skill_description call")+ }++ async fn describe_new_skill(+ &self,+ _document_id: &str,+ _description: crate::domain::skill_description::SkillDescription,+ ) -> Result<(), DocumentError> {+ Ok(())+ }++ async fn skill_descriptions(+ &self,+ _document_ids: &[String],+ ) -> Result<+ std::collections::HashMap<String, crate::domain::skill_description::SkillDescription>,+ DocumentError,+ > {+ Ok(std::collections::HashMap::new())+ }}impl DocumentCreationService for FakeDocumentService {diff --git a/crates/documents/src/outbound/pg_document_repo.rs b/crates/documents/src/outbound/pg_document_repo.rsindex 64424e119a..caf058c21a 100644--- a/crates/documents/src/outbound/pg_document_repo.rs+++ b/crates/documents/src/outbound/pg_document_repo.rs@@ -1037,6 +1037,58 @@ impl<B: BotFacts + 'static> DocumentRepo for PgDocumentRepo<B> {share::set_team_share(&self.pool, command).await}+ #[tracing::instrument(err, skip(self, document_ids), fields(skills = document_ids.len()))]+ async fn get_skill_descriptions(+ &self,+ document_ids: &[String],+ ) -> Result<+ std::collections::HashMap<String, crate::domain::skill_description::SkillDescription>,+ Self::Err,+ > {+ let rows = sqlx::query!(+ r#"+ SELECT document_id, description+ FROM skill_description+ WHERE document_id = ANY($1)+ "#,+ document_ids,+ )+ .fetch_all(&self.pool)+ .await?;+ Ok(rows+ .into_iter()+ .map(|row| {+ (+ row.document_id,+ crate::domain::skill_description::SkillDescription::from_stored(+ row.description,+ ),+ )+ })+ .collect())+ }++ #[tracing::instrument(err, skip(self, description))]+ async fn set_skill_description(+ &self,+ document_id: &str,+ description: &crate::domain::skill_description::SkillDescription,+ ) -> Result<(), Self::Err> {+ sqlx::query!(+ r#"+ INSERT INTO skill_description (document_id, description)+ VALUES ($1, $2)+ ON CONFLICT (document_id)+ DO UPDATE SET description = EXCLUDED.description, updated_at = now()+ "#,+ document_id,+ description.as_str(),+ )+ .execute(&self.pool)+ .await?;+ Ok(())+ }+#[tracing::instrument(err, skip(self))]async fn get_document_metadata_at_version(&self,diff --git a/crates/documents/src/outbound/pg_document_repo/tests.rs b/crates/documents/src/outbound/pg_document_repo/tests.rsindex 2cf3e16ef0..fbdfa60655 100644--- a/crates/documents/src/outbound/pg_document_repo/tests.rs+++ b/crates/documents/src/outbound/pg_document_repo/tests.rs@@ -3509,3 +3509,37 @@ async fn test_get_github_pull_request_task_links_returns_requested_keys_oldest_f]);}++#[sqlx::test(+ migrator = "MACRO_DB_MIGRATIONS",+ fixtures(path = "../../../fixtures", scripts("documents_test_data"))+)]+async fn skill_descriptions_are_stored_replaced_and_read_by_id(pool: Pool<Postgres>) {+ use crate::domain::skill_description::SkillDescription;+ let repo = test_repo(pool);+ let described = "d0000000-0000-0000-0000-000000000003";+ let undescribed = "d0000000-0000-0000-0000-000000000004";++ repo.set_skill_description(+ described,+ &SkillDescription::parse("Use when drafting notes").unwrap(),+ )+ .await+ .unwrap();+ repo.set_skill_description(+ described,+ &SkillDescription::parse("Use when drafting release notes; not changelogs").unwrap(),+ )+ .await+ .unwrap();++ let descriptions = repo+ .get_skill_descriptions(&[described.to_owned(), undescribed.to_owned()])+ .await+ .unwrap();+ assert_eq!(descriptions.len(), 1);+ assert_eq!(+ descriptions[described].as_str(),+ "Use when drafting release notes; not changelogs"+ );+}diff --git a/crates/github/src/domain/service/sync/test.rs b/crates/github/src/domain/service/sync/test.rsindex d4a079abe4..b8e3b41b18 100644--- a/crates/github/src/domain/service/sync/test.rs+++ b/crates/github/src/domain/service/sync/test.rs@@ -335,6 +335,34 @@ impl DocumentService for StubDocumentService {) -> anyhow::Result<()> {unimplemented!()}++ async fn set_skill_description(+ &self,+ _entity_access_receipt: entity_access::domain::models::EntityAccessReceipt<+ models_permissions::share_permission::access_level::EditAccessLevel,+ >,+ _description: documents::domain::skill_description::SkillDescription,+ ) -> Result<(), documents::domain::models::DocumentError> {+ panic!("unexpected set_skill_description call")+ }++ async fn describe_new_skill(+ &self,+ _document_id: &str,+ _description: documents::domain::skill_description::SkillDescription,+ ) -> Result<(), documents::domain::models::DocumentError> {+ Ok(())+ }++ async fn skill_descriptions(+ &self,+ _document_ids: &[String],+ ) -> Result<+ std::collections::HashMap<String, documents::domain::skill_description::SkillDescription>,+ documents::domain::models::DocumentError,+ > {+ Ok(std::collections::HashMap::new())+ }}/// Stateful stub repo that tracks task IDs per github key.diff --git a/crates/macro_db_client/migrations/20261104175726_skill_description.sql b/crates/macro_db_client/migrations/20261104175726_skill_description.sqlnew file mode 100644index 0000000000..2550bb1120--- /dev/null+++ b/crates/macro_db_client/migrations/20261104175726_skill_description.sql@@ -0,0 +1,14 @@+-- When to use a skill, in one line ("Use when ...; not ..."). Agents route+-- requests to skills on it, so it is kept apart from the skill's body. A skill+-- created before descriptions existed has no row and routes by its name.+CREATE TABLE "skill_description"+(+ "document_id" TEXT NOT NULL,+ "description" TEXT NOT NULL,+ "updated_at" TIMESTAMPTZ NOT NULL DEFAULT now(),++ CONSTRAINT "skill_description_pkey" PRIMARY KEY ("document_id"),+ CONSTRAINT "skill_description_document_id_fkey" FOREIGN KEY ("document_id")+ REFERENCES "Document" ("id") ON DELETE CASCADE ON UPDATE CASCADE,+ CONSTRAINT "skill_description_length" CHECK (char_length("description") BETWEEN 1 AND 300)+);diff --git a/crates/skills/AGENTS.md b/crates/skills/AGENTS.mdindex 27abcd2e54..4a926bbaba 100644--- a/crates/skills/AGENTS.md+++ b/crates/skills/AGENTS.md@@ -13,6 +13,9 @@ instructions an agent follows when the skill is referenced in its input.default implementation.- `src/inbound/toolset.rs`: the three AI tools — `search_skills.rs`,`list_skills.rs`, `read_skill.rs`.+- `src/domain/selection.rs`: `select_skills`, the Jev router agents use to+ load the user's skills a request needs (`agent.skill_selection` span).+ Design: `docs/architecture/agent-skills.md`.- `src/outbound/`: `document_skill_reader.rs` (reads skill content),`search_service_searcher.rs` (search), `soup_skill_lister.rs` (listing).@@ -27,7 +30,8 @@ instructions an agent follows when the skill is referenced in its input.- Depends on: `document_sub_type`, `entity_access` (ports); `outbound` featureadditionally needs `documents`, `search_service_client`, `soup`,`lexical_client`, `item_filters`, `filter_ast`.-- Used by: `ai_tools`.+- Used by: `ai_tools`, `agent_inmem` (skill routing). Descriptions come from+ `documents` (`skill_descriptions`); system skills have none.## Recipesdiff --git a/crates/skills/Cargo.toml b/crates/skills/Cargo.tomlindex 0b87351fc5..4b70fdebd9 100644--- a/crates/skills/Cargo.toml+++ b/crates/skills/Cargo.toml@@ -26,11 +26,16 @@ ports = [][dependencies]anyhow = { workspace = true }chrono = { workspace = true }+cognition = { path = "../cognition" }+futures = { workspace = true }document_sub_type = { path = "../document_sub_type" }entity_access = { path = "../entity_access", default-features = false, features = ["ports"] }macro_user_id = { path = "../macro_user_id" }system_skills = { path = "../system_skills" }+serde_json = { workspace = true }thiserror = { workspace = true }+tokio = { workspace = true, features = ["macros", "time"] }+tokio-util = { workspace = true }tracing = { workspace = true }uuid = { workspace = true }@@ -56,5 +61,6 @@ soup = { path = "../soup", default-features = false, features = ["ports"], optioworkspace-hack = { version = "0.1", path = "../workspace-hack" }[dev-dependencies]-serde_json = { workspace = true }-tokio = { workspace = true, features = ["macros", "rt"] }+async-trait = { workspace = true }+rootcause = { workspace = true }+tokio = { workspace = true, features = ["macros", "rt", "test-util"] }diff --git a/crates/skills/src/domain.rs b/crates/skills/src/domain.rsindex 47511f19d5..36a0ce8847 100644--- a/crates/skills/src/domain.rs+++ b/crates/skills/src/domain.rs@@ -2,4 +2,5 @@pub mod model;pub mod ports;+pub mod selection;pub mod service;diff --git a/crates/skills/src/domain/model.rs b/crates/skills/src/domain/model.rsindex 6332cbb354..571520ea86 100644--- a/crates/skills/src/domain/model.rs+++ b/crates/skills/src/domain/model.rs@@ -9,6 +9,8 @@ pub struct SkillSummary {pub document_id: uuid::Uuid,/// The name of the skill.pub name: String,+ /// When to use the skill. Only system skills have one so far.+ pub description: Option<String>,/// When the skill document was last updated, when known.pub updated_at: Option<DateTime<Utc>>,}diff --git a/crates/skills/src/domain/ports.rs b/crates/skills/src/domain/ports.rsindex 7df677e31e..7fdada8eb5 100644--- a/crates/skills/src/domain/ports.rs+++ b/crates/skills/src/domain/ports.rs@@ -58,6 +58,13 @@ pub trait SkillService: Send + Sync + 'static {&self,user_id: &MacroUserIdStr<'_>,) -> impl Future<Output = Result<Vec<SkillSummary>, SkillError>> + Send;++ /// The user's skills an agent may load without being asked, as many as+ /// routing considers, most recently updated first, with their descriptions.+ fn list_routable_skills(+ &self,+ user_id: &MacroUserIdStr<'_>,+ ) -> impl Future<Output = Result<Vec<SkillSummary>, SkillError>> + Send;}/// Capabilities for accessing skill documents and their current markdown.@@ -75,6 +82,13 @@ pub trait SkillReader: Send + Sync + 'static {receipt: &EntityAccessReceipt<ViewAccessLevel>,) -> impl Future<Output = Result<SkillDocumentMetadata, SkillError>> + Send;+ /// The descriptions of skills already listed for the caller, by id.+ /// Skills with no description are left out.+ fn descriptions(+ &self,+ document_ids: &[uuid::Uuid],+ ) -> impl Future<Output = Result<std::collections::HashMap<uuid::Uuid, String>, SkillError>> + Send;+/// Read the complete current markdown of an authorized document.fn markdown(&self,diff --git a/crates/skills/src/domain/selection.rs b/crates/skills/src/domain/selection.rsnew file mode 100644index 0000000000..a0b9ba4778--- /dev/null+++ b/crates/skills/src/domain/selection.rs@@ -0,0 +1,412 @@+//! Which of the user's skills a request needs, decided by Jev before an+//! agent's turn.+//!+//! The user's most recently updated skills are the candidates. Jev answers one+//! yes/no question per candidate, built from its "Use when …" description, at+//! most 32 per call, so candidates are split into parallel calls, at most+//! [`MAX_CALLS`]. A skill redirects the agent, so only a confident match+//! loads.++#[cfg(test)]+mod test;++use std::sync::Arc;+use std::time::Duration;++use cognition::domain::{Cognition, DecisionRequest};+use futures::future::join_all;+use macro_user_id::user_id::MacroUserIdStr;+use tokio_util::sync::CancellationToken;+use uuid::Uuid;++use crate::domain::model::{SkillError, SkillSummary};+use crate::domain::ports::SkillService;++/// Questions Jev answers in one call.+const QUESTIONS_PER_CALL: usize = 32;+/// Parallel Jev calls per turn; candidates past `MAX_CALLS * 32` are not+/// routed, and stay reachable through `ReadSkill`.+pub const MAX_CALLS: usize = 8;+/// How long the turn waits for Jev.+const DECISION_DEADLINE: Duration = Duration::from_secs(1);+/// How long the turn waits for the chosen skills' instructions.+const READ_DEADLINE: Duration = Duration::from_secs(1);+/// Skills scoring at least this load, most relevant first, at most+/// [`LOAD_LIMIT`].+const LOAD_THRESHOLD: f32 = 0.8;+const LOAD_LIMIT: usize = 2;+/// A skill created before descriptions existed routes on its name alone, and+/// a generic name ("Brand voice") matches too much, so it loads only when the+/// request all but names it.+const UNDESCRIBED_LOAD_THRESHOLD: f32 = 0.95;+/// Skills scoring at least this, but not loaded, are recorded as suggested.+const SUGGEST_THRESHOLD: f32 = 0.5;+/// Jev's limits on one question and on the request text it reads.+const MAX_QUESTION_CHARS: usize = 500;+const MAX_REQUEST_CHARS: usize = 8000;++/// The user's words the turn answers.+#[derive(Debug, Clone, Copy)]+pub struct SkillRequest<'a> {+ /// The newest user message.+ pub latest: &'a str,+ /// The user message before it, so a follow-up such as "now do it for Q3"+ /// keeps the skill the conversation is using.+ pub previous: Option<&'a str>,+}++/// A skill chosen for a turn, with its instructions.+#[derive(Debug, Clone, PartialEq)]+pub struct LoadedSkill {+ /// The skill document id, or built-in skill id.+ pub id: Uuid,+ /// The skill's display name.+ pub name: String,+ /// Jev's probability that the request needs it.+ pub score: f32,+ /// The skill's full instructions.+ pub content: String,+}++/// How routing ended.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum SelectionStatus {+ /// Jev scored the candidates; nothing loading is a decision too.+ Selected,+ /// There was nothing to ask about.+ NoCandidates,+ /// No cognition service is configured.+ Unconfigured,+ /// The turn was cancelled first.+ Cancelled,+ /// Listing skills or every Jev call failed.+ ProviderError,+ /// Jev did not answer before the deadline.+ Timeout,+}++impl SelectionStatus {+ /// The status as recorded on spans.+ pub fn as_str(self) -> &'static str {+ match self {+ Self::Selected => "selected",+ Self::NoCandidates => "no_candidates",+ Self::Unconfigured => "unconfigured",+ Self::Cancelled => "cancelled",+ Self::ProviderError => "provider_error",+ Self::Timeout => "timeout",+ }+ }+}++/// What routing chose for one turn.+#[derive(Debug, Clone, PartialEq)]+pub struct SkillSelection {+ /// Skills Jev was asked about.+ pub candidates: usize,+ /// Skills to load, most relevant first.+ pub loaded: Vec<LoadedSkill>,+ /// Skills that may help but fell short of loading.+ pub suggested: Vec<SkillSummary>,+ /// How routing ended.+ pub status: SelectionStatus,+ /// The highest score any candidate got.+ pub top_score: Option<f32>,+}++impl SkillSelection {+ fn nothing(candidates: usize, status: SelectionStatus) -> Self {+ Self {+ candidates,+ loaded: Vec::new(),+ suggested: Vec::new(),+ status,+ top_score: None,+ }+ }+}++/// Choose the skills a request needs. Never fails: anything that goes wrong+/// loads nothing and says why in the status.+///+/// `already_loaded` skills are in the conversation already and are not asked+/// about again; neither is a skill the request mentions, whose mention+/// carries its id and which the agent reads itself.+#[tracing::instrument(+ name = "agent.skill_selection",+ skip_all,+ fields(+ candidates = tracing::field::Empty,+ loaded = tracing::field::Empty,+ suggested = tracing::field::Empty,+ top_score = tracing::field::Empty,+ bytes = tracing::field::Empty,+ selection_status = tracing::field::Empty,+ )+)]+pub async fn select_skills<Svc: SkillService>(+ service: &Svc,+ cognition: Option<&Arc<dyn Cognition>>,+ user: &MacroUserIdStr<'static>,+ request: SkillRequest<'_>,+ already_loaded: &[Uuid],+ cancel: &CancellationToken,+) -> SkillSelection {+ let selection = select(service, cognition, user, request, already_loaded, cancel).await;+ let span = tracing::Span::current();+ span.record("candidates", selection.candidates);+ span.record(+ "loaded",+ selection+ .loaded+ .iter()+ .map(|skill| skill.id.to_string())+ .collect::<Vec<_>>()+ .join(","),+ );+ span.record(+ "suggested",+ selection+ .suggested+ .iter()+ .map(|skill| skill.document_id.to_string())+ .collect::<Vec<_>>()+ .join(","),+ );+ if let Some(score) = selection.top_score {+ span.record("top_score", f64::from(score));+ }+ span.record(+ "bytes",+ selection+ .loaded+ .iter()+ .map(|skill| skill.content.len())+ .sum::<usize>(),+ );+ span.record("selection_status", selection.status.as_str());+ selection+}++async fn select<Svc: SkillService>(+ service: &Svc,+ cognition: Option<&Arc<dyn Cognition>>,+ user: &MacroUserIdStr<'static>,+ request: SkillRequest<'_>,+ already_loaded: &[Uuid],+ cancel: &CancellationToken,+) -> SkillSelection {+ let Some(cognition) = cognition else {+ return SkillSelection::nothing(0, SelectionStatus::Unconfigured);+ };+ let skills = tokio::select! {+ biased;+ _ = cancel.cancelled() => return SkillSelection::nothing(0, SelectionStatus::Cancelled),+ // Boxed, like the read below: a production service's futures are deep+ // enough to overflow the layout of a caller's future that holds them.+ skills = Box::pin(service.list_routable_skills(user)) => skills,+ };+ let skills = match skills {+ Ok(skills) => skills,+ Err(error) => {+ tracing::warn!(error = %error, "could not list skills to route");+ return SkillSelection::nothing(0, SelectionStatus::ProviderError);+ }+ };+ let candidates = candidates(skills, request, already_loaded);+ if candidates.is_empty() {+ return SkillSelection::nothing(0, SelectionStatus::NoCandidates);+ }+ let scored = tokio::select! {+ biased;+ _ = cancel.cancelled() => {+ return SkillSelection::nothing(candidates.len(), SelectionStatus::Cancelled);+ }+ scored = tokio::time::timeout(DECISION_DEADLINE, score(cognition.as_ref(), user, request, &candidates)) => scored,+ };+ let scores = match scored {+ Ok(Some(scores)) => scores,+ Ok(None) => {+ return SkillSelection::nothing(candidates.len(), SelectionStatus::ProviderError);+ }+ Err(_) => return SkillSelection::nothing(candidates.len(), SelectionStatus::Timeout),+ };+ let top_score = scores.iter().map(|(_, score)| *score).reduce(f32::max);+ let (chosen, suggested) = choose(scores);+ let loaded = tokio::select! {+ biased;+ _ = cancel.cancelled() => {+ return SkillSelection::nothing(candidates.len(), SelectionStatus::Cancelled);+ }+ loaded = read(service, user, chosen) => loaded,+ };+ SkillSelection {+ candidates: candidates.len(),+ loaded,+ suggested,+ status: SelectionStatus::Selected,+ top_score,+ }+}++/// The routable skills not already in the conversation, in the order listed+/// (most recently updated first), up to what [`MAX_CALLS`] can ask about.+fn candidates(+ skills: Vec<SkillSummary>,+ request: SkillRequest<'_>,+ already_loaded: &[Uuid],+) -> Vec<SkillSummary> {+ let mut candidates: Vec<SkillSummary> = skills+ .into_iter()+ .filter(|skill| !already_loaded.contains(&skill.document_id))+ .filter(|skill| !request.latest.contains(&skill.document_id.to_string()))+ .collect();+ candidates.truncate(MAX_CALLS * QUESTIONS_PER_CALL);+ candidates+}++/// Every candidate's score, or `None` when no call succeeded.+async fn score(+ cognition: &dyn Cognition,+ user: &MacroUserIdStr<'static>,+ request: SkillRequest<'_>,+ candidates: &[SkillSummary],+) -> Option<Vec<(SkillSummary, f32)>> {+ let mut input = serde_json::json!({ "request": clip(request.latest, MAX_REQUEST_CHARS) });+ if let Some(previous) = request.previous {+ input["previousRequest"] = clip(previous, MAX_REQUEST_CHARS).into();+ }+ let calls = candidates.chunks(QUESTIONS_PER_CALL).map(|chunk| {+ let request = DecisionRequest {+ input: input.clone(),+ questions: chunk+ .iter()+ .map(|skill| (skill.document_id.to_string(), question(skill)))+ .collect(),+ };+ cognition.decide(user, request)+ });+ let answers = join_all(calls).await;+ let mut scores = Vec::new();+ let mut answered = false;+ for answer in answers {+ match answer {+ Ok(answer) => {+ answered = true;+ scores.extend(answer.probabilities.into_iter().filter_map(|(key, score)| {+ let skill = candidates+ .iter()+ .find(|skill| skill.document_id.to_string() == key)?;+ score.is_finite().then(|| (skill.clone(), score))+ }));+ }+ Err(error) => tracing::warn!(error = %error, "Jev could not route skills"),+ }+ }+ answered.then_some(scores)+}++fn question(skill: &SkillSummary) -> String {+ let question = match &skill.description {+ Some(description) => format!(+ "Would the skill \"{}\" help with this request? {description}",+ skill.name+ ),+ None => format!("Would the skill \"{}\" help with this request?", skill.name),+ };+ clip(&question, MAX_QUESTION_CHARS)+}++fn clip(text: &str, chars: usize) -> String {+ text.chars().take(chars).collect()+}++/// The skills to load, and skills worth recording as suggested, each most+/// relevant first.+fn choose(mut scores: Vec<(SkillSummary, f32)>) -> (Vec<(SkillSummary, f32)>, Vec<SkillSummary>) {+ scores.sort_by(|a, b| {+ b.1.total_cmp(&a.1)+ .then_with(|| a.0.document_id.cmp(&b.0.document_id))+ });+ let mut chosen = Vec::new();+ let mut suggested = Vec::new();+ for (skill, score) in scores {+ let threshold = if skill.description.is_some() {+ LOAD_THRESHOLD+ } else {+ UNDESCRIBED_LOAD_THRESHOLD+ };+ if score >= threshold && chosen.len() < LOAD_LIMIT {+ chosen.push((skill, score));+ } else if score >= SUGGEST_THRESHOLD {+ suggested.push(skill);+ }+ }+ (chosen, suggested)+}++/// Read the chosen skills' instructions; a skill that cannot be read in time+/// is left out.+async fn read<Svc: SkillService>(+ service: &Svc,+ user: &MacroUserIdStr<'static>,+ chosen: Vec<(SkillSummary, f32)>,+) -> Vec<LoadedSkill> {+ let reads = chosen.iter().map(|(skill, _)| async {+ tokio::time::timeout(+ READ_DEADLINE,+ Box::pin(service.read_skill(user, skill.document_id)),+ )+ .await+ .unwrap_or_else(|_| {+ Err(SkillError::ReadFailed(anyhow::anyhow!(+ "reading the skill took too long"+ )))+ })+ });+ let contents = join_all(reads).await;+ chosen+ .into_iter()+ .zip(contents)+ .filter_map(|((skill, score), content)| match content {+ Ok(content) => Some(LoadedSkill {+ id: skill.document_id,+ name: content.name,+ score,+ content: content.content,+ }),+ Err(error) => {+ tracing::warn!(error = %error, skill_id = %skill.document_id, "could not read a routed skill");+ None+ }+ })+ .collect()+}++/// Loaded skills as one tagged block for the turn's context; empty when none+/// are loaded.+pub fn render_loaded(skills: &[LoadedSkill]) -> String {+ if skills.is_empty() {+ return String::new();+ }+ let mut section = String::from(+ "<loaded_skills>\nThese of the user's skills were loaded because this request needs them. Follow each where the request calls for it, and only there.\n",+ );+ for skill in skills {+ section.push_str(&format!(+ "<skill name=\"{}\" id=\"{}\">\n{}\n</skill>\n",+ escape_attribute(&skill.name),+ skill.id,+ skill.content.trim_end()+ ));+ }+ section.push_str("</loaded_skills>");+ section+}++fn escape_attribute(text: &str) -> String {+ text.replace('&', "&")+ .replace('"', """)+ .replace('<', "<")+ .replace('>', ">")+}diff --git a/crates/skills/src/domain/selection/test.rs b/crates/skills/src/domain/selection/test.rsnew file mode 100644index 0000000000..5f53b96a4c--- /dev/null+++ b/crates/skills/src/domain/selection/test.rs@@ -0,0 +1,418 @@+use std::collections::BTreeMap;+use std::sync::Mutex;++use async_trait::async_trait;+use cognition::domain::{DecisionResponse, GenerateObjectRequest, GenerateObjectResponse};+use rootcause::Report;++use super::*;+use crate::domain::model::{SkillContent, SkillMatchType};++/// Answers each question with the score its skill was given, 0.1 otherwise.+struct Jev {+ scores: BTreeMap<Uuid, f32>,+ delay: Duration,+ fail: bool,+ calls: Mutex<Vec<DecisionRequest>>,+}++impl Jev {+ fn scoring(scores: &[(u128, f32)]) -> Arc<Self> {+ Arc::new(Self {+ scores: scores+ .iter()+ .map(|(id, score)| (Uuid::from_u128(*id), *score))+ .collect(),+ delay: Duration::ZERO,+ fail: false,+ calls: Mutex::new(Vec::new()),+ })+ }++ fn asked(&self) -> Vec<Vec<String>> {+ self.calls+ .lock()+ .unwrap()+ .iter()+ .map(|request| request.questions.keys().cloned().collect())+ .collect()+ }+}++#[async_trait]+impl Cognition for Jev {+ async fn generate_object(+ &self,+ _: &MacroUserIdStr<'static>,+ _: GenerateObjectRequest,+ ) -> Result<GenerateObjectResponse, Report> {+ panic!("skill selection must not generate text")+ }++ async fn decide(+ &self,+ _: &MacroUserIdStr<'static>,+ request: DecisionRequest,+ ) -> Result<DecisionResponse, Report> {+ let probabilities = request+ .questions+ .keys()+ .map(|key| {+ let id: Uuid = key.parse().unwrap();+ (key.clone(), self.scores.get(&id).copied().unwrap_or(0.1))+ })+ .collect();+ self.calls.lock().unwrap().push(request);+ tokio::time::sleep(self.delay).await;+ if self.fail {+ return Err(rootcause::report!("unavailable"));+ }+ Ok(DecisionResponse { probabilities })+ }+}++/// The user's skills, every body readable unless listed as unreadable.+struct Skills {+ user: Vec<SkillSummary>,+ unreadable: Vec<Uuid>,+}++impl Skills {+ fn numbered(count: usize) -> Self {+ Self {+ user: (1..=count as u128)+ .map(|id| SkillSummary {+ document_id: Uuid::from_u128(id),+ name: format!("Skill {id}"),+ description: Some(format!("Use when doing thing {id}")),+ updated_at: None,+ })+ .collect(),+ unreadable: Vec::new(),+ }+ }+}++impl SkillService for Skills {+ async fn read_skill(+ &self,+ _: &MacroUserIdStr<'_>,+ document_id: Uuid,+ ) -> Result<SkillContent, SkillError> {+ if self.unreadable.contains(&document_id) {+ return Err(SkillError::NotASkill);+ }+ let skill = self+ .user+ .iter()+ .find(|skill| skill.document_id == document_id)+ .expect("only listed skills are read");+ Ok(SkillContent {+ document_id,+ name: skill.name.clone(),+ content: format!("Instructions for {}.", skill.name),+ })+ }++ async fn search_skills(+ &self,+ _: &MacroUserIdStr<'_>,+ _: &str,+ _: SkillMatchType,+ ) -> Result<Vec<SkillSummary>, SkillError> {+ panic!("skill selection must not search")+ }++ async fn list_skills(&self, _: &MacroUserIdStr<'_>) -> Result<Vec<SkillSummary>, SkillError> {+ panic!("skill selection lists routable skills")+ }++ async fn list_routable_skills(+ &self,+ _: &MacroUserIdStr<'_>,+ ) -> Result<Vec<SkillSummary>, SkillError> {+ Ok(self.user.clone())+ }+}++fn owner() -> MacroUserIdStr<'static> {+ MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap()+}++fn ids(selection: &SkillSelection) -> Vec<u128> {+ selection+ .loaded+ .iter()+ .map(|skill| skill.id.as_u128())+ .collect()+}++async fn select(+ skills: &Skills,+ jev: Option<Arc<Jev>>,+ latest: &str,+ loaded: &[Uuid],+) -> SkillSelection {+ let jev = jev.map(|jev| jev as Arc<dyn Cognition>);+ select_skills(+ skills,+ jev.as_ref(),+ &owner(),+ SkillRequest {+ latest,+ previous: None,+ },+ loaded,+ &CancellationToken::new(),+ )+ .await+}++#[tokio::test]+async fn an_irrelevant_request_loads_nothing() {+ let jev = Jev::scoring(&[]);++ let selection = select(+ &Skills::numbered(3),+ Some(jev.clone()),+ "Thanks, that's perfect!",+ &[],+ )+ .await;++ assert_eq!(selection.status, SelectionStatus::Selected);+ assert!(selection.loaded.is_empty());+ assert!(selection.suggested.is_empty());+ assert_eq!(selection.candidates, 3);+ assert_eq!(jev.asked().len(), 1);+}++#[tokio::test]+async fn a_matching_request_loads_that_skill_with_its_instructions() {+ let selection = select(+ &Skills::numbered(3),+ Some(Jev::scoring(&[(2, 0.9)])),+ "request",+ &[],+ )+ .await;++ assert_eq!(ids(&selection), [2]);+ assert_eq!(selection.loaded[0].content, "Instructions for Skill 2.");+ assert_eq!(selection.top_score, Some(0.9));+}++#[tokio::test]+async fn at_most_two_load_most_relevant_first_and_unsure_ones_are_suggested() {+ let jev = Jev::scoring(&[(1, 0.85), (2, 0.99), (3, 0.9), (4, 0.6), (5, 0.79)]);++ let selection = select(&Skills::numbered(5), Some(jev), "request", &[]).await;++ assert_eq!(ids(&selection), [2, 3]);+ let suggested: Vec<u128> = selection+ .suggested+ .iter()+ .map(|skill| skill.document_id.as_u128())+ .collect();+ assert_eq!(suggested, [1, 5, 4]);+}++#[tokio::test]+async fn loaded_and_mentioned_skills_are_not_asked_about() {+ let jev = Jev::scoring(&[(1, 0.9), (3, 0.9)]);+ let mentioned = Uuid::from_u128(3);+ let request = format!(+ "Use <m-document-mention>{{\"documentId\":\"{mentioned}\",\"documentName\":\"\",\"blockName\":\"skill\",\"blockParams\":{{}}}}</m-document-mention> on this"+ );++ let selection = select(+ &Skills::numbered(3),+ Some(jev.clone()),+ &request,+ &[Uuid::from_u128(1)],+ )+ .await;++ assert!(selection.loaded.is_empty());+ assert_eq!(jev.asked().concat(), [Uuid::from_u128(2).to_string()]);+ assert_eq!(selection.candidates, 1);+}++#[tokio::test]+async fn candidates_split_into_calls_of_at_most_32_questions() {+ let jev = Jev::scoring(&[]);++ select(&Skills::numbered(70), Some(jev.clone()), "request", &[]).await;++ let sizes: Vec<usize> = jev.asked().iter().map(Vec::len).collect();+ assert_eq!(sizes.len(), 3);+ assert!(sizes.iter().all(|size| *size <= 32));+ assert_eq!(sizes.iter().sum::<usize>(), 70);+}++#[tokio::test]+async fn at_most_eight_calls_route_the_256_most_recent_skills() {+ let jev = Jev::scoring(&[]);++ let selection = select(&Skills::numbered(300), Some(jev.clone()), "request", &[]).await;++ let asked = jev.asked();+ assert_eq!(asked.len(), 8);+ let asked = asked.concat();+ assert_eq!(asked.len(), 256);+ assert_eq!(selection.candidates, 256);+ assert!(asked.contains(&Uuid::from_u128(256).to_string()));+ assert!(!asked.contains(&Uuid::from_u128(257).to_string()));+}++#[tokio::test]+async fn an_unreadable_skill_is_not_loaded() {+ let skills = Skills {+ unreadable: vec![Uuid::from_u128(1)],+ ..Skills::numbered(2)+ };++ let selection = select(+ &skills,+ Some(Jev::scoring(&[(1, 0.95), (2, 0.9)])),+ "request",+ &[],+ )+ .await;++ assert_eq!(ids(&selection), [2]);+}++#[tokio::test(start_paused = true)]+async fn a_slow_classifier_loads_nothing_after_the_deadline() {+ let jev = Arc::new(Jev {+ scores: [(Uuid::from_u128(1), 0.9)].into_iter().collect(),+ delay: Duration::from_secs(5),+ fail: false,+ calls: Mutex::new(Vec::new()),+ });++ let selection = select(&Skills::numbered(2), Some(jev), "request", &[]).await;++ assert_eq!(selection.status, SelectionStatus::Timeout);+ assert!(selection.loaded.is_empty());+}++#[tokio::test]+async fn a_failing_or_absent_classifier_or_no_skills_load_nothing() {+ let failing = Arc::new(Jev {+ scores: [(Uuid::from_u128(1), 0.9)].into_iter().collect(),+ delay: Duration::ZERO,+ fail: true,+ calls: Mutex::new(Vec::new()),+ });++ let failed = select(&Skills::numbered(2), Some(failing), "request", &[]).await;+ let absent = select(&Skills::numbered(2), None, "request", &[]).await;+ let none = select(+ &Skills::numbered(0),+ Some(Jev::scoring(&[])),+ "request",+ &[],+ )+ .await;++ assert_eq!(failed.status, SelectionStatus::ProviderError);+ assert_eq!(absent.status, SelectionStatus::Unconfigured);+ assert_eq!(none.status, SelectionStatus::NoCandidates);+ for selection in [failed, absent, none] {+ assert!(selection.loaded.is_empty());+ }+}++#[tokio::test]+async fn the_classifier_sees_the_request_and_each_description() {+ let jev = Jev::scoring(&[]);+ let skills = Skills {+ user: vec![+ SkillSummary {+ document_id: Uuid::from_u128(1),+ name: "Release notes".into(),+ description: Some("Use when drafting release notes; not changelogs".into()),+ updated_at: None,+ },+ SkillSummary {+ document_id: Uuid::from_u128(2),+ name: "Old skill".into(),+ description: None,+ updated_at: None,+ },+ ],+ unreadable: Vec::new(),+ };+ let cognition: Arc<dyn Cognition> = jev.clone();++ select_skills(+ &skills,+ Some(&cognition),+ &owner(),+ SkillRequest {+ latest: "now do it for Q3",+ previous: Some("summarise Q2 revenue"),+ },+ &[],+ &CancellationToken::new(),+ )+ .await;++ let request = jev.calls.lock().unwrap().remove(0);+ assert_eq!(+ request.input,+ serde_json::json!({"request": "now do it for Q3", "previousRequest": "summarise Q2 revenue"})+ );+ assert_eq!(+ request.questions[&Uuid::from_u128(1).to_string()],+ "Would the skill \"Release notes\" help with this request? Use when drafting release notes; not changelogs"+ );+ // A skill made before descriptions existed routes on its name.+ assert_eq!(+ request.questions[&Uuid::from_u128(2).to_string()],+ "Would the skill \"Old skill\" help with this request?"+ );+}++#[test]+fn loaded_skills_render_as_one_tagged_section() {+ let rendered = render_loaded(&[LoadedSkill {+ id: Uuid::from_u128(7),+ name: "Release notes".to_string(),+ score: 0.9,+ content: "Write release notes as bullet points.".to_string(),+ }]);++ assert!(rendered.starts_with("<loaded_skills>\n"));+ assert!(rendered.contains(&format!(+ "<skill name=\"Release notes\" id=\"{}\">\nWrite release notes as bullet points.\n</skill>",+ Uuid::from_u128(7)+ )));+ assert!(rendered.ends_with("</loaded_skills>"));+ assert_eq!(render_loaded(&[]), "");+}++#[tokio::test]+async fn a_skill_without_a_description_needs_near_certainty_to_load() {+ let mut skills = Skills::numbered(2);+ skills.user[0].description = None;+ skills.user[1].description = None;++ let selection = select(+ &skills,+ Some(Jev::scoring(&[(1, 0.93), (2, 0.96)])),+ "request",+ &[],+ )+ .await;++ assert_eq!(ids(&selection), [2]);+ let suggested: Vec<u128> = selection+ .suggested+ .iter()+ .map(|skill| skill.document_id.as_u128())+ .collect();+ assert_eq!(suggested, [1]);+}diff --git a/crates/skills/src/domain/service.rs b/crates/skills/src/domain/service.rsindex eff4faf300..5ab57a480a 100644--- a/crates/skills/src/domain/service.rs+++ b/crates/skills/src/domain/service.rs@@ -10,6 +10,9 @@ use crate::domain::ports::{SkillLister, SkillReader, SkillSearcher, SkillService/// Maximum number of skills returned from a single listing.const LIST_LIMIT: u16 = 100;+/// Maximum number of the user's skills routing considers: eight Jev calls of+/// 32 questions (see [`crate::domain::selection`]).+const ROUTABLE_LIMIT: u16 = 256;/// Skill domain service backed by discovery and authorized document reading ports.#[derive(Debug, Clone)]@@ -44,6 +47,7 @@ fn system_skill_summaries() -> impl Iterator<Item = SkillSummary> {.map(|skill| SkillSummary {document_id: skill.id(),name: skill.name.to_string(),+ description: None,updated_at: None,})}@@ -150,6 +154,7 @@ impl<S: SkillSearcher, L: SkillLister, R: SkillReader> SkillService for SkillSeruser_id: &MacroUserIdStr<'_>,) -> Result<Vec<SkillSummary>, SkillError> {let mut skills = self.lister.list_skills(user_id, LIST_LIMIT).await?;+ self.describe(&mut skills).await?;// System skills are visible to everyone; having no update timestamp,// they sort after every user skill.@@ -159,4 +164,27 @@ impl<S: SkillSearcher, L: SkillLister, R: SkillReader> SkillService for SkillSerOk(skills)}++ #[tracing::instrument(skip(self), err)]+ async fn list_routable_skills(+ &self,+ user_id: &MacroUserIdStr<'_>,+ ) -> Result<Vec<SkillSummary>, SkillError> {+ let mut skills = self.lister.list_skills(user_id, ROUTABLE_LIMIT).await?;+ self.describe(&mut skills).await?;+ sort_most_recently_updated_first(&mut skills);+ Ok(skills)+ }+}++impl<S, L, R: SkillReader> SkillServiceImpl<S, L, R> {+ /// Fill in the descriptions of listed user skills.+ async fn describe(&self, skills: &mut [SkillSummary]) -> Result<(), SkillError> {+ let ids: Vec<uuid::Uuid> = skills.iter().map(|skill| skill.document_id).collect();+ let mut descriptions = self.reader.descriptions(&ids).await?;+ for skill in skills {+ skill.description = descriptions.remove(&skill.document_id);+ }+ Ok(())+ }}diff --git a/crates/skills/src/domain/service/test.rs b/crates/skills/src/domain/service/test.rsindex b38df2734f..d64d57528c 100644--- a/crates/skills/src/domain/service/test.rs+++ b/crates/skills/src/domain/service/test.rs@@ -98,6 +98,7 @@ fn skill(id: u128, name: &str, updated_at_secs: Option<i64>) -> SkillSummary {SkillSummary {document_id: uuid::Uuid::from_u128(id),name: name.to_string(),+ description: None,updated_at: updated_at_secs.map(|secs| Utc.timestamp_opt(secs, 0).unwrap()),}}@@ -150,6 +151,7 @@ async fn search_includes_matching_system_skills() {vec![SkillSummary {document_id: system_skills::catch_me_up::SKILL.id(),name: "Catch Me Up".to_string(),+ description: None,updated_at: None,}]);@@ -310,6 +312,18 @@ impl SkillReader for FakeReader {.ok_or_else(|| SkillError::ReadFailed(anyhow::anyhow!("missing document")))}+ /// Skill 1 alone has a description.+ async fn descriptions(+ &self,+ document_ids: &[uuid::Uuid],+ ) -> Result<std::collections::HashMap<uuid::Uuid, String>, SkillError> {+ Ok(document_ids+ .iter()+ .filter(|id| **id == uuid::Uuid::from_u128(1))+ .map(|id| (*id, "Use when reviewing code; not writing it".to_string()))+ .collect())+ }+async fn markdown(&self,receipt: EntityAccessReceipt<ViewAccessLevel>,@@ -473,3 +487,51 @@ async fn discovery_and_reading_work_through_json_tool_dispatch() {.is_err());}++#[tokio::test]+async fn listings_carry_the_descriptions_skills_have() {+ let service = || {+ discovery_service(+ FakeSearcher::unused(),+ FakeLister::returning(vec![+ skill(1, "review", Some(100)),+ skill(2, "notes", Some(200)),+ ]),+ )+ };++ let listed = service().list_skills(&user()).await.unwrap();+ let routable = service().list_routable_skills(&user()).await.unwrap();++ for results in [&listed, &routable] {+ let described = results+ .iter()+ .find(|skill| skill.document_id == uuid::Uuid::from_u128(1))+ .unwrap();+ assert_eq!(+ described.description.as_deref(),+ Some("Use when reviewing code; not writing it")+ );+ let undescribed = results+ .iter()+ .find(|skill| skill.document_id == uuid::Uuid::from_u128(2))+ .unwrap();+ assert_eq!(undescribed.description, None);+ }+}++#[tokio::test]+async fn only_the_users_skills_are_routable_newest_first() {+ let service = discovery_service(+ FakeSearcher::unused(),+ FakeLister::returning(vec![+ skill(1, "older", Some(100)),+ skill(2, "newer", Some(300)),+ ]),+ );++ let routable = service.list_routable_skills(&user()).await.unwrap();++ let names: Vec<&str> = routable.iter().map(|skill| skill.name.as_str()).collect();+ assert_eq!(names, ["newer", "older"]);+}diff --git a/crates/skills/src/inbound/toolset/list_skills.rs b/crates/skills/src/inbound/toolset/list_skills.rsindex 3bfd2801af..ffa7423759 100644--- a/crates/skills/src/inbound/toolset/list_skills.rs+++ b/crates/skills/src/inbound/toolset/list_skills.rs@@ -54,6 +54,7 @@ impl<Svc: SkillService> AsyncTool<SkillToolContext<Svc>> for ListSkills {.map(|skill| SkillSearchResult {document_id: skill.document_id,name: skill.name,+ description: skill.description,updated_at: skill.updated_at,}).collect(),diff --git a/crates/skills/src/inbound/toolset/search_skills.rs b/crates/skills/src/inbound/toolset/search_skills.rsindex 30b630ff93..a328ab8827 100644--- a/crates/skills/src/inbound/toolset/search_skills.rs+++ b/crates/skills/src/inbound/toolset/search_skills.rs@@ -61,6 +61,9 @@ pub struct SkillSearchResult {pub document_id: Uuid,/// The name of the skill.pub name: String,+ /// When to use the skill, when it says.+ #[serde(skip_serializing_if = "Option::is_none")]+ pub description: Option<String>,/// When the skill was last updated, when known.#[serde(skip_serializing_if = "Option::is_none")]pub updated_at: Option<DateTime<Utc>>,@@ -109,6 +112,7 @@ impl<Svc: SkillService> AsyncTool<SkillToolContext<Svc>> for SearchSkills {.map(|skill| SkillSearchResult {document_id: skill.document_id,name: skill.name,+ description: skill.description,updated_at: skill.updated_at,}).collect(),diff --git a/crates/skills/src/outbound/document_skill_reader.rs b/crates/skills/src/outbound/document_skill_reader.rsindex 40dcc75621..2f31fb45c3 100644--- a/crates/skills/src/outbound/document_skill_reader.rs+++ b/crates/skills/src/outbound/document_skill_reader.rs@@ -68,6 +68,24 @@ impl<D: DocumentService, A: EntityAccessService> SkillReader for DocumentSkillRe})}+ async fn descriptions(+ &self,+ document_ids: &[Uuid],+ ) -> Result<std::collections::HashMap<Uuid, String>, SkillError> {+ let ids: Vec<String> = document_ids.iter().map(Uuid::to_string).collect();+ let descriptions = self+ .documents+ .skill_descriptions(&ids)+ .await+ .map_err(|error| SkillError::ListFailed(error.into()))?;+ Ok(descriptions+ .into_iter()+ .filter_map(|(id, description)| {+ Some((Uuid::parse_str(&id).ok()?, description.as_str().to_owned()))+ })+ .collect())+ }+async fn markdown(&self,receipt: EntityAccessReceipt<ViewAccessLevel>,diff --git a/crates/skills/src/outbound/search_service_searcher.rs b/crates/skills/src/outbound/search_service_searcher.rsindex 6430720220..6605fd580b 100644--- a/crates/skills/src/outbound/search_service_searcher.rs+++ b/crates/skills/src/outbound/search_service_searcher.rs@@ -74,6 +74,7 @@ impl SkillSearcher for SearchServiceSkillSearcher {UnifiedSearchResponseItem::Document(doc) => Some(SkillSummary {document_id: doc.extra.id,name: doc.extra.document_name,+ description: None,updated_at: doc.metadata.as_ref().map(|m| m.updated_at),}),_ => None,diff --git a/crates/skills/src/outbound/soup_skill_lister.rs b/crates/skills/src/outbound/soup_skill_lister.rsindex 0d9d944642..79154f1868 100644--- a/crates/skills/src/outbound/soup_skill_lister.rs+++ b/crates/skills/src/outbound/soup_skill_lister.rs@@ -121,6 +121,7 @@ impl<S: SoupService> SkillLister for SoupSkillLister<S> {SoupItem::Document(doc) => Some(SkillSummary {document_id: doc.id,name: doc.name,+ description: None,updated_at: Some(doc.updated_at),}),_ => None,diff --git a/docs/agent-guide/ai-chat.md b/docs/agent-guide/ai-chat.mdindex e728fec777..ed8656f85d 100644--- a/docs/agent-guide/ai-chat.md+++ b/docs/agent-guide/ai-chat.md@@ -476,6 +476,13 @@ the shimmer.**Add connections** opens Discover; **Manage connections** opens Connected.Disabled connections remain available to manage. A partial loading failureoffers Retry without hiding uploads, references, or skills.+- Skills have a one-line **When to use** description ("Use when …; not …"),+ required in the skill composer (`C K`) under the name and editable under+ the title of an open skill (saves on blur or Enter; an invalid line shows+ an error below it). Owners with the `auto-skills` flag get up to two of+ their skills loaded on their own when a session request matches a+ description; the session view shows nothing for it, and the+ `agent.skill_selection` span says what loaded.- Empty conversation greetings use Roboto Slab with the Macro mark to the left,at weight 390 with softened ink in light mode and 315 in dark mode, including the Chat and Codestarting headings, legacy Home, and the conversation preview empty state.diff --git a/docs/architecture/agent-skills.md b/docs/architecture/agent-skills.mdnew file mode 100644index 0000000000..aa967e9118--- /dev/null+++ b/docs/architecture/agent-skills.md@@ -0,0 +1,52 @@+# Agent skills++A skill is a markdown document (sub type `skill`) of instructions an agent+follows. Built-in system skills (`crates/system_skills`) work the same way but+have no document.++## Descriptions++Every skill has a one-line description saying when to use it ("Use when …;+not …"), stored in `skill_description` (one row per skill document, at most+300 characters) and validated by `documents::domain::skill_description`.++- Creating a skill requires one: `POST /documents/create_skill`, the+ `CreateSkill` tool, `macro.documents.createSkill({description})` and the+ skill composer all reject a blank, multi-line, long or non-"Use when" line+ before creating anything.+- `GET`/`PUT /documents/{id}/skill_description` read and change it (View and+ Edit access); the web app edits it under an open skill's title.+- Skills made before descriptions existed have no row and route on their+ name alone, at a higher bar (below).++## Loading skills a request needs++Behind the `auto-skills` PostHog flag, `agent_inmem` routes each+conversation turn before it runs, in the same join as memory and SDK docs:++```+turn ─┬─ memory, SDK docs, auto model ...+ └─ skills::domain::selection::select_skills+ list ≤256 of the user's skills (soup, access-checked), newest first,+ with descriptions; skip ones this session loaded or the request @mentions+ ceil(n/32) parallel Jev calls (≤8): "Would skill X help? <description>"+ 1 s deadline; any failure loads nothing and the turn runs as usual+ load ≥0.8 (≥0.95 without a description), at most 2, most relevant first+ read bodies through ReadSkill's access check, 1 s+ ▼+ SessionSkills remembers (request number, skill) per session (≤8, in memory)+ inject: each skill's <loaded_skills> block is appended to the user message+ that loaded it, in the model's copy of the conversation only+```++Keeping a skill on the request that loaded it keeps every earlier turn's+text identical, so the prompt cache holds, and the skill stays in effect for+the rest of the session without routing again. After a restart a session+routes again from its next message.++`agent.skill_selection` records `candidates`, `loaded` and `suggested` skill+ids, `top_score`, `bytes` and `selection_status`; never names or request text.++`route_evaluation` in `crates/agent_inmem/src/domain/skill_routing/eval.rs`+(ignored; needs `TYPESAFE_API_KEY`) routes 20 prompts over a fixture skill+set through the real Jev and prints the hit rate at several thresholds.diff --git a/packages/sdk/generated/storage/index.ts b/packages/sdk/generated/storage/index.tsindex 2253d4f201..b04c8815b5 100644--- a/packages/sdk/generated/storage/index.ts+++ b/packages/sdk/generated/storage/index.ts@@ -1,4 +1,4 @@// This file is auto-generated by @hey-api/openapi-tsexport { type Options, Sdk } from './sdk.gen';-export type { AccentColor, AccessiblePipeline, AccessLevel, AccessRequest, AccessRequestsCancelData, AccessRequestsCancelErrors, AccessRequestsCancelResponses, AccessRequestsDirectData, AccessRequestsDirectErrors, AccessRequestsDirectResponse, AccessRequestsDirectResponses, AccessRequestsRemoveDirectData, AccessRequestsRemoveDirectErrors, AccessRequestsRemoveDirectResponses, AccessRequestsResolveData, AccessRequestsResolveErrors, AccessRequestsResolveResponse, AccessRequestsResolveResponses, AccessRequestsSetDirectData, AccessRequestsSetDirectErrors, AccessRequestsSetDirectResponses, AccessRequestsStateData, AccessRequestsStateErrors, AccessRequestsStateResponse, AccessRequestsStateResponses, AccessRequestsSubmitData, AccessRequestsSubmitErrors, AccessRequestsSubmitResponse, AccessRequestsSubmitResponses, AccessRequestState, ActiveCallsResponse, ActiveCallSummary, ActiveMeeting, ActiveMeetingsResponse, ActivityType, AddFavoriteData, AddFavoriteError, AddFavoriteErrors, AddFavoriteRequest, AddFavoriteResponse, AddFavoriteResponses, AddParticipantsData, AddParticipantsError, AddParticipantsErrors, AddParticipantsRequest, AddParticipantsResponses, AddPinHandlerData, AddPinHandlerError, AddPinHandlerErrors, AddPinHandlerResponse, AddPinHandlerResponses, AddPinRequest, Agent, AgentActionId, AgentChannelScope, AgentDmProfile, AgentMcpServer, AgentMcpServers, AgentPullRequestState, AgentSessionArchiveCause, AgentSessionFilters, AgentSessionLifecycleEvent, AgentSessionSource, AgentSessionVisibility, AgentTyping, AgentTypingPhase, AiAdmissionErrorBody, Anchor, AnchorId, AnchorResponse, AnnotationIncrementalUpdate, Answer, ApiActivity, ApiAttachmentChannelReference, ApiAttachmentCommentReference, ApiAttachmentEntityReference, ApiAttachmentGenericReference, ApiChannelAttachment, ApiChannelAttachmentsPage, ApiChannelDetail, ApiChannelListMessage, ApiChannelListPage, ApiChannelListParticipant, ApiChannelListType, ApiChannelParticipant, ApiChannelWithLatest, ApiEntityFilterAst, ApiGroupByField, ApiGroupMeta, ApiParticipantListRole, ApiParticipantRole, ApiPropertyEntityType, AppliedOps, ApplyCrmPipelineOpsData, ApplyCrmPipelineOpsResponse, ApplyCrmPipelineOpsResponses, ApplyDatabaseOpsData, ApplyDatabaseOpsError, ApplyDatabaseOpsErrors, ApplyDatabaseOpsResponse, ApplyDatabaseOpsResponses, ApplyOpsRequest, ApplyOpsResponse, ApproveHarnessPairingData, ApproveHarnessPairingError, ApproveHarnessPairingErrors, ApproveHarnessPairingResponse, ApproveHarnessPairingResponses, ApprovePairingRequest, AttachmentChange, AttendeeResponseStatus, Audience, Awareness, AwarenessRelay, BasicDocument, BasicDocumentSubType, BlockCrmDomainData, BlockCrmDomainError, BlockCrmDomainErrors, BlockCrmDomainResponse, BlockCrmDomainResponses, BomPart, BookingTarget, Bot, BotChannel, BotChannelType, BotId, BotKind, BotOwner, BotOwnerProfile, BotSenderProfile, BotToken, BranchNameResponse, BTreeMap, BulkWakeupRequest, BulkWakeupResponse, BulkWakeupSyncServiceDocumentsData, BulkWakeupSyncServiceDocumentsErrors, BulkWakeupSyncServiceDocumentsResponse, BulkWakeupSyncServiceDocumentsResponses, CalendarAttendee, CalendarEvent, CalendarEventFilters, CalendarEventSourceContent, CalendarJoinRequest, CalendarJoinRequestApiError, CalendarJoinRequestErrorCode, CalendarJoinRequestsResponse, CalendarJoinRequestStatus, CalendarMentionEvent, CalendarMentionPreviewItem, CalendarMentionPreviewKind, CalendarMentionPreviewRequest, CalendarMentionPreviewRequestItem, CalendarMentionPreviewResponse, CalendarMentionViewerCopy, CalendarOccurrence, CalendarOccurrenceItem, CalendarOccurrenceResponse, CalendarSyncStatus, CallActiveResponse, CallFilters, CallProvider, CallRecord, CallRecordGuest, CallRecordParticipant, CallRecordPreview, CallRecordPreviewData, CallRecordSource, CallRecordTranscriptSegment, CallStatus, CallTokenResponse, CallWebhookData, CallWebhookError, CallWebhookErrors, CallWebhookResponses, CancelSlackImportData, CancelSlackImportErrors, CancelSlackImportResponse, CancelSlackImportResponses, CardPosition, CastVerdict, CellValue, CellWrite, ChangedFileDto, ChangesetDto, ChangesetSourceDto, Channel, ChannelCreatedMetadata, ChannelDeletedMetadata, ChannelFilters, ChannelJoinCodeResponse, ChannelLabel, ChannelLabelRule, ChannelLabelScopeSelection, ChannelLabelsList, ChannelMessage, ChannelParticipant, ChannelParticipantAddedMetadata, ChannelParticipantRemovedMetadata, ChannelPictureChangedMetadata, ChannelPreview, ChannelPreviewData, ChannelSender, ChannelSharePermission, ChannelThreadFilters, ChannelTopicEvent, ChannelType, ChannelUpdatedMetadata, ChannelWebhookRequest, ChannelWebhookResponse, ChannelWithParticipants, Chat, ChatFilters, CheckActiveCallData, CheckActiveCallError, CheckActiveCallErrors, CheckActiveCallResponse, CheckActiveCallResponses, ClaimedPairing, ClaimHarnessPairingData, ClaimHarnessPairingError, ClaimHarnessPairingErrors, ClaimHarnessPairingResponse, ClaimHarnessPairingResponses, ClaimPairingRequest, ClientOptions, CloudStorageItemType, CollaborateFormData, CollaborateFormError, CollaborateFormErrors, CollaborateFormResponse, CollaborateFormResponses, CollabSurfaceResponse, CollabSurfaceTokenResponse, Column, ColumnCast, ColumnChange, ColumnChangeKind, ColumnConfig, ColumnConversion, ColumnConversionRequest, ColumnDetail, ColumnId, ColumnKind, ColumnProtection, ColumnResult, CommandFailure, CommandRejectedMetadata, CommittedChange, CompleteSlackImportUploadsData, CompleteSlackImportUploadsErrors, CompleteSlackImportUploadsResponse, CompleteSlackImportUploadsResponses, CompleteUploads, ConferenceProvider, Conjunction, ConversationId, ConversationKind, ConversationMetadata, ConversationProgress, ConversationSeal, ConversationStatus, ConvertDatabaseColumnData, ConvertDatabaseColumnError, ConvertDatabaseColumnErrors, ConvertDatabaseColumnResponse, ConvertDatabaseColumnResponses, ConvertedCell, CopyDocumentData, CopyDocumentError, CopyDocumentErrors, CopyDocumentQueryParams, CopyDocumentRequest, CopyDocumentResponse, CopyDocumentResponse2, CopyDocumentResponses, CountedReaction, CreateAgentData, CreateAgentError, CreateAgentErrors, CreateAgentRequest, CreateAgentResponse, CreateAgentResponses, CreateAnchorData, CreateAnchorError, CreateAnchorErrors, CreateAnchorResponse, CreateAnchorResponses, CreateBotRequest, CreateBulkDocumentResponse, CreateBulkDocumentResponseData, CreateCanvasDocumentRequest, CreateCanvasDocumentResponse, CreateCanvasHandlerData, CreateCanvasHandlerError, CreateCanvasHandlerErrors, CreateCanvasHandlerResponse, CreateCanvasHandlerResponses, CreateChannelData, CreateChannelError, CreateChannelErrors, CreateChannelLabelData, CreateChannelLabelError, CreateChannelLabelErrors, CreateChannelLabelRequest, CreateChannelLabelResponse, CreateChannelLabelResponses, CreateChannelRequest, CreateChannelResponse, CreateChannelResponse2, CreateChannelResponses, CreateChannelScopedBotData, CreateChannelScopedBotError, CreateChannelScopedBotErrors, CreateChannelScopedBotRequest, CreateChannelScopedBotResponse, CreateChannelScopedBotResponse2, CreateChannelScopedBotResponses, CreateCollabSurfaceTokenData, CreateCollabSurfaceTokenError, CreateCollabSurfaceTokenErrors, CreateCollabSurfaceTokenResponse, CreateCollabSurfaceTokenResponses, CreateCrmCompanyData, CreateCrmCompanyError, CreateCrmCompanyErrors, CreateCrmCompanyRequest, CreateCrmCompanyResponse, CreateCrmCompanyResponses, CreateCrmContactData, CreateCrmContactError, CreateCrmContactErrors, CreateCrmContactRequest, CreateCrmContactResponse, CreateCrmContactResponses, CreateCrmPipelineData, CreateCrmPipelineResponse, CreateCrmPipelineResponses, CreateCrmTeamContactData, CreateCrmTeamContactError, CreateCrmTeamContactErrors, CreateCrmTeamContactRequest, CreateCrmTeamContactResponse, CreateCrmTeamContactResponses, CreateDatabaseData, CreateDatabaseError, CreateDatabaseErrors, CreateDatabaseRequest, CreateDatabaseResponse, CreateDatabaseResponses, CreateDatabaseWebhookData, CreateDatabaseWebhookError, CreateDatabaseWebhookErrors, CreateDatabaseWebhookRequest, CreateDatabaseWebhookResponse, CreateDatabaseWebhookResponses, CreatedDatabaseWebhookResponse, CreateDocumentData, CreateDocumentError, CreateDocumentErrors, CreateDocumentRequest, CreateDocumentResponse, CreateDocumentResponseData, CreateDocumentResponses, CreatedPairing, CreatedUserApiKey, CreateEntityMentionData, CreateEntityMentionError, CreateEntityMentionErrors, CreateEntityMentionRequest, CreateEntityMentionResponse, CreateEntityMentionResponse2, CreateEntityMentionResponses, CreateForm, CreateFormData, CreateFormError, CreateFormErrors, CreateFormResponse, CreateFormResponses, CreateHarnessPairingData, CreateHarnessPairingError, CreateHarnessPairingErrors, CreateHarnessPairingResponse, CreateHarnessPairingResponses, CreateImport, CreateInitiativeData, CreateInitiativeError, CreateInitiativeErrors, CreateInitiativeRequest, CreateInitiativeResponse, CreateInitiativeResponses, CreateInstructionsDocumentResponse, CreateInstructionsHandlerData, CreateInstructionsHandlerError, CreateInstructionsHandlerErrors, CreateInstructionsHandlerResponse, CreateInstructionsHandlerResponses, CreateMarkdownDocumentRequest, CreateMarkdownDocumentResponse, CreateMarkdownHandlerData, CreateMarkdownHandlerError, CreateMarkdownHandlerErrors, CreateMarkdownHandlerResponse, CreateMarkdownHandlerResponses, CreateMeetingRequest, CreatePairingRequest, CreatePipeline, CreateProjectHandlerData, CreateProjectHandlerError, CreateProjectHandlerErrors, CreateProjectHandlerResponse, CreateProjectHandlerResponses, CreateProjectRequest, CreateProjectResponse, CreateSkillHandlerData, CreateSkillHandlerError, CreateSkillHandlerErrors, CreateSkillHandlerResponse, CreateSkillHandlerResponses, CreateSkillRequest, CreateSkillResponse, CreateSlackImportData, CreateSlackImportErrors, CreateSlackImportResponse, CreateSlackImportResponses, CreateSnippetHandlerData, CreateSnippetHandlerError, CreateSnippetHandlerErrors, CreateSnippetHandlerResponse, CreateSnippetHandlerResponses, CreateSnippetRequest, CreateSnippetResponse, CreateTaskHandlerData, CreateTaskHandlerError, CreateTaskHandlerErrors, CreateTaskHandlerResponse, CreateTaskHandlerResponses, CreateTaskRequest, CreateTaskResponse, CreateToken, CreateUnthreadedAnchorRequest, CreateUnthreadedAnchorResponse, CreateUnthreadedPdfAnchorRequest, CreateUserApiKeyData, CreateUserApiKeyError, CreateUserApiKeyErrors, CreateUserApiKeyRequest, CreateUserApiKeyResponse, CreateUserApiKeyResponses, CreateViewHandlerData, CreateViewHandlerError, CreateViewHandlerErrors, CreateViewHandlerResponse, CreateViewHandlerResponses, CreateViewRequest, CreateWebhookData, CreateWebhookError, CreateWebhookErrors, CreateWebhookRequest, CreateWebhookResponse, CreateWebhookResponse2, CreateWebhookResponses, CrmAssociation, CrmBlockedDomainResponse, CrmCompanyFilters, CrmCompanyResponse, CrmContactResponse, CrmDomainResponse, CrmPermissionRole, CrmStageInput, CrmStageResponse, CrmStagesResponse, CrmTeamSettingsResponse, CustomSpeakerAssignment, Database, DatabaseDetail, DatabaseId, DatabaseOp, DatabaseQueryRequest, DatabaseView, DatabaseWebhookDeliveryResponse, DatabaseWebhookPayloadProblem, DatabaseWebhookResponse, DataType, DateOperator, DateRange, DateRangeOperator, DeclineCallData, DeclineCallError, DeclineCallErrors, DeclineCallResponse, DeclineCallResponses, DeclineRingData, DeclineRingError, DeclineRingErrors, DeclineRingResponse, DeclineRingResponses, DeleteAnchorData, DeleteAnchorError, DeleteAnchorErrors, DeleteAnchorResponse, DeleteAnchorResponses, DeleteCallRecordData, DeleteCallRecordError, DeleteCallRecordErrors, DeleteCallRecordResponse, DeleteCallRecordResponses, DeleteChannelData, DeleteChannelError, DeleteChannelErrors, DeleteChannelLabelData, DeleteChannelLabelError, DeleteChannelLabelErrors, DeleteChannelLabelResponse, DeleteChannelLabelResponses, DeleteChannelResponse, DeleteChannelResponses, DeleteCollabSurfaceData, DeleteCollabSurfaceError, DeleteCollabSurfaceErrors, DeleteCollabSurfaceResponse, DeleteCollabSurfaceResponses, DeleteDatabaseWebhookData, DeleteDatabaseWebhookError, DeleteDatabaseWebhookErrors, DeleteDatabaseWebhookResponse, DeleteDatabaseWebhookResponses, DeleteDocumentData, DeleteDocumentError, DeleteDocumentErrors, DeleteDocumentResponse, DeleteDocumentResponses, DeleteEntityMentionData, DeleteEntityMentionError, DeleteEntityMentionErrors, DeleteEntityMentionResponse, DeleteEntityMentionResponse2, DeleteEntityMentionResponses, DeleteHarnessData, DeleteHarnessError, DeleteHarnessErrors, DeleteHarnessResponse, DeleteHarnessResponses, DeleteHistoryHandlerData, DeleteHistoryHandlerError, DeleteHistoryHandlerErrors, DeleteHistoryHandlerResponse, DeleteHistoryHandlerResponses, DeleteInitiativeData, DeleteInitiativeError, DeleteInitiativeErrors, DeleteInitiativeResponse, DeleteInitiativeResponses, DeleteProjectHandlerData, DeleteProjectHandlerError, DeleteProjectHandlerErrors, DeleteProjectHandlerResponse, DeleteProjectHandlerResponses, DeleteSelfHarnessData, DeleteSelfHarnessError, DeleteSelfHarnessErrors, DeleteSelfHarnessResponse, DeleteSelfHarnessResponses, DeleteUnthreadedAnchorRequest, DeleteUnthreadedAnchorResponse, DeleteUnthreadedPdfAnchorRequest, DeleteUserApiKeyData, DeleteUserApiKeyError, DeleteUserApiKeyErrors, DeleteUserApiKeyResponse, DeleteUserApiKeyResponses, DeleteUserDocumentViewLocationData, DeleteUserDocumentViewLocationError, DeleteUserDocumentViewLocationErrors, DeleteUserDocumentViewLocationResponse, DeleteUserDocumentViewLocationResponses, DeleteViewHandlerData, DeleteViewHandlerError, DeleteViewHandlerErrors, DeleteViewHandlerResponses, DeleteWebhookData, DeleteWebhookError, DeleteWebhookErrors, DeleteWebhookResponse, DeleteWebhookResponses, DeliverDatabaseWebhookData, DeliverDatabaseWebhookError, DeliverDatabaseWebhookErrors, DeliverDatabaseWebhookResponse, DeliverDatabaseWebhookResponses, DirectAccess, DocumentAiEdited, DocumentAiEditFailed, DocumentAiEditFailedCode, DocumentAiEditRefused, DocumentAiEditRefusedCode, DocumentAiEditRequest, DocumentBasic, DocumentContent, DocumentContentLocation, DocumentContentState, DocumentContentUploadedMetadata, DocumentCopiedMetadata, DocumentCreatedMetadata, DocumentDeletedMetadata, DocumentFilters, DocumentId, DocumentInteractionMetadata, DocumentMetadata, DocumentMetadataWithContent, DocumentPermissionsToken, DocumentPermissionsTokenRequest, DocumentPermissionsTokenResponse, DocumentPreview, DocumentPreviewData, DocumentPreviewDataSubType, DocumentPurgedMetadata, DocumentResponse, DocumentResponseMetadata, DocumentResponseMetadataWithContent, DocumentStorageServiceApiVersion, DocumentSubType, DocumentSyncContentUpdatedMetadata, DocumentSyncEditor, DocumentTeamShareResponse, DocumentTextContent, DocumentTopicEvent, DocumentUpdatedMetadata, DuplicateDatabaseData, DuplicateDatabaseError, DuplicateDatabaseErrors, DuplicateDatabaseRequest, DuplicateDatabaseResponse, DuplicateDatabaseResponses, EditAnchorData, EditAnchorError, EditAnchorErrors, EditAnchorRequest, EditAnchorResponse, EditAnchorResponse2, EditAnchorResponses, EditCallRecordData, EditCallRecordError, EditCallRecordErrors, EditCallRecordRequest, EditCallRecordResponse, EditCallRecordResponses, EditCallTranscriptData, EditCallTranscriptError, EditCallTranscriptErrors, EditCallTranscriptRequest, EditCallTranscriptResponse, EditCallTranscriptResponses, EditDocumentData, EditDocumentError, EditDocumentErrors, EditDocumentResponse, EditDocumentResponse2, EditDocumentResponses, EditDocumentServiceArgs, EditDocumentWithAiData, EditDocumentWithAiError, EditDocumentWithAiErrors, EditDocumentWithAiResponse, EditDocumentWithAiResponses, EditMyFormResponseData, EditMyFormResponseError, EditMyFormResponseErrors, EditMyFormResponseResponse, EditMyFormResponseResponses, EditPdfAnchorRequest, EditPdfPlaceableCommentAnchorRequest, EditProjectV2Data, EditProjectV2Error, EditProjectV2Errors, EditProjectV2Response, EditProjectV2Responses, EditThreadV2Data, EditThreadV2Error, EditThreadV2Errors, EditThreadV2Response, EditThreadV2Responses, EmailFilters, EmailFollowup, EmailFollowupCommand, EmailFollowupResponse, EmailReminderCondition, EmailReminderPage, EmailReminderSummary, EmptyResponse, EnsureCollabSurfaceData, EnsureCollabSurfaceError, EnsureCollabSurfaceErrors, EnsureCollabSurfaceRequest, EnsureCollabSurfaceResponse, EnsureCollabSurfaceResponses, EnsureStarterHandlerData, EnsureStarterHandlerErrors, EnsureStarterHandlerResponse, EnsureStarterHandlerResponses, EntityFilters, EntityKind, EntityMessageCreateData, EntityMessageCreateResponse, EntityMessageCreateResponses, EntityMessageDeleteMessageData, EntityMessageDeleteMessageResponse, EntityMessageDeleteMessageResponses, EntityMessageDeleteThreadData, EntityMessageDeleteThreadResponse, EntityMessageDeleteThreadResponses, EntityMessageEditData, EntityMessageEditResponse, EntityMessageEditResponses, EntityMessageGetMessageData, EntityMessageGetMessageResponse, EntityMessageGetMessageResponses, EntityMessageGetThreadData, EntityMessageGetThreadResponse, EntityMessageGetThreadResponses, EntityMessageLegacyData, EntityMessageLegacyResponse, EntityMessageLegacyResponses, EntityMessagePatchThreadData, EntityMessagePatchThreadResponse, EntityMessagePatchThreadResponses, EntityMessageReactData, EntityMessageReactResponse, EntityMessageReactResponses, EntityMessageTypingData, EntityMessageTypingResponse, EntityMessageTypingResponses, EntityPermission, EntityPermissionResponse, EntityRef, EntityReference, EntityType, ErrorResponse, EventIcsData, EventIcsErrors, EventIcsResponse, EventIcsResponses, EventReminderOverride, EventReminders, EventStatus, EventTime, EventTransparency, EventType, EventVisibility, ExcludedDefaultView, ExcludeDefaultViewHandlerData, ExcludeDefaultViewHandlerError, ExcludeDefaultViewHandlerErrors, ExcludeDefaultViewHandlerResponses, ExcludeDefaultViewRequest, ExportDocumentData, ExportDocumentError, ExportDocumentErrors, ExportDocumentResponse, ExportDocumentResponse2, ExportDocumentResponses, ExternalChatAdd, ExternalChatAddData, ExternalChatAdded, ExternalChatAddResponse, ExternalChatAddResponses, ExternalChatAttachment, ExternalChatAttachmentState, ExternalChatBackfill, ExternalChatBackfillState, ExternalChatCall, ExternalChatCallOutcome, ExternalChatCapabilities, ExternalChatCommunity, ExternalChatContactCard, ExternalChatContacts, ExternalChatData, ExternalChatDeliveryData, ExternalChatDeliveryResponse, ExternalChatDeliveryResponses, ExternalChatDeliveryState, ExternalChatDetail, ExternalChatEvent, ExternalChatKind, ExternalChatLocation, ExternalChatMediaKind, ExternalChatMediaPresentation, ExternalChatMembers, ExternalChatMention, ExternalChatMessage, ExternalChatMessageAttachments, ExternalChatMessageAttachmentsData, ExternalChatMessageAttachmentsResponse, ExternalChatMessageAttachmentsResponses, ExternalChatMessageData, ExternalChatMessageKind, ExternalChatMessageResponse, ExternalChatMessageResponses, ExternalChatMessages, ExternalChatMessagesData, ExternalChatMessagesResponse, ExternalChatMessagesResponses, ExternalChatMutation, ExternalChatParticipant, ExternalChatPermissionsData, ExternalChatPermissionsResponse, ExternalChatPermissionsResponses, ExternalChatPersonRef, ExternalChatPoll, ExternalChatPollOption, ExternalChatProvider, ExternalChatReaction, ExternalChatReadData, ExternalChatReadResponse, ExternalChatReadResponses, ExternalChatReference, ExternalChatRemoveData, ExternalChatRemoveResponse, ExternalChatRemoveResponses, ExternalChatReplyBlock, ExternalChatReplyContent, ExternalChatResponse, ExternalChatResponses, ExternalChatRichContent, ExternalChatsData, ExternalChatSendData, ExternalChatSender, ExternalChatSendErrors, ExternalChatSendProgress, ExternalChatSendReply, ExternalChatSendResponse, ExternalChatSendResponses, ExternalChatSendsData, ExternalChatSendsResponse, ExternalChatSendsResponses, ExternalChatsResponse, ExternalChatsResponses, ExternalChatSummary, ExternalChatSystemAction, ExternalChatSystemLine, ExternalChatUpdatePermissionsData, ExternalChatUpdatePermissionsResponse, ExternalChatUpdatePermissionsResponses, ExternalChatUploadData, ExternalChatUploadedAttachment, ExternalChatUploadRequest, ExternalChatUploadResponse, ExternalChatUploadResponses, Favorite, FavoriteEntityRef, FavoritesList, FileChangeKindDto, FileSystemNodeWithIds, FileType, FileTypeUpdate, FilterCondition, FilterGroup, FilterNode, FilterTest, FinalizeSlackImportData, FinalizeSlackImportErrors, FinalizeSlackImportResponse, FinalizeSlackImportResponses, FolderItem, FollowupState, ForeignEntity, ForeignEntityFilters, Form, FormAccess, FormBranding, FormCollaboration, FormDetail, FormErrorCode, FormErrorResponse, FormLayout, FormPublicationProblem, FormQuestionDetail, FormResponse, FormSection, FormSectionDetail, FormSource, FormStatus, FormTally, Formula, GenericErrorResponse, GenericResponse, GenericSuccessResponse, GetActiveCallsData, GetActiveCallsError, GetActiveCallsErrors, GetActiveCallsResponse, GetActiveCallsResponses, GetActivityData, GetActivityError, GetActivityErrors, GetActivityResponse, GetActivityResponses, GetAttachmentReferencesData, GetAttachmentReferencesError, GetAttachmentReferencesErrors, GetAttachmentReferencesResponse, GetAttachmentReferencesResponse2, GetAttachmentReferencesResponses, GetBatchCallRecordPreviewData, GetBatchCallRecordPreviewError, GetBatchCallRecordPreviewErrors, GetBatchCallRecordPreviewRequest, GetBatchCallRecordPreviewResponse, GetBatchCallRecordPreviewResponse2, GetBatchCallRecordPreviewResponses, GetBatchChannelPreviewData, GetBatchChannelPreviewError, GetBatchChannelPreviewErrors, GetBatchChannelPreviewRequest, GetBatchChannelPreviewResponse, GetBatchChannelPreviewResponse2, GetBatchChannelPreviewResponses, GetBatchPreviewHandlerData, GetBatchPreviewHandlerError, GetBatchPreviewHandlerErrors, GetBatchPreviewHandlerResponse, GetBatchPreviewHandlerResponses, GetBatchPreviewRequest, GetBatchPreviewResponse, GetBatchProjectPreviewData, GetBatchProjectPreviewError, GetBatchProjectPreviewErrors, GetBatchProjectPreviewRequest, GetBatchProjectPreviewResponse, GetBatchProjectPreviewResponse2, GetBatchProjectPreviewResponses, GetBotOwnerProfilesData, GetBotOwnerProfilesError, GetBotOwnerProfilesErrors, GetBotOwnerProfilesResponse, GetBotOwnerProfilesResponses, GetCallRecordData, GetCallRecordError, GetCallRecordErrors, GetCallRecordResponse, GetCallRecordResponses, GetChannelAttachmentsData, GetChannelAttachmentsError, GetChannelAttachmentsErrors, GetChannelAttachmentsResponse, GetChannelAttachmentsResponses, GetChannelData, GetChannelError, GetChannelErrors, GetChannelJoinLinkData, GetChannelJoinLinkError, GetChannelJoinLinkErrors, GetChannelJoinLinkResponse, GetChannelJoinLinkResponses, GetChannelParticipantsData, GetChannelParticipantsError, GetChannelParticipantsErrors, GetChannelParticipantsResponse, GetChannelParticipantsResponses, GetChannelResponse, GetChannelResponses, GetChannelsData, GetChannelsError, GetChannelsErrors, GetChannelsResponse, GetChannelsResponses, GetCollabSurfaceData, GetCollabSurfaceError, GetCollabSurfaceErrors, GetCollabSurfaceResponse, GetCollabSurfaceResponses, GetCompanyData, GetCompanyError, GetCompanyErrors, GetCompanyResponse, GetCompanyResponses, GetContactByEmailData, GetContactByEmailError, GetContactByEmailErrors, GetContactByEmailResponse, GetContactByEmailResponse2, GetContactByEmailResponses, GetContactData, GetContactError, GetContactErrors, GetContactResponse, GetContactResponses, GetCrmPipelineData, GetCrmPipelinePermissionsData, GetCrmPipelinePermissionsResponse, GetCrmPipelinePermissionsResponses, GetCrmPipelineResponse, GetCrmPipelineResponses, GetCrmPipelineRowsData, GetCrmPipelineRowsResponse, GetCrmPipelineRowsResponses, GetCrmPipelineTableData, GetCrmPipelineTableResponse, GetCrmPipelineTableResponses, GetCrmPipelineViewPositionsData, GetCrmPipelineViewPositionsResponse, GetCrmPipelineViewPositionsResponses, GetCrmTeamSettingsData, GetCrmTeamSettingsError, GetCrmTeamSettingsErrors, GetCrmTeamSettingsResponse, GetCrmTeamSettingsResponses, GetDatabaseData, GetDatabaseError, GetDatabaseErrors, GetDatabasePermissionsData, GetDatabasePermissionsError, GetDatabasePermissionsErrors, GetDatabasePermissionsResponse, GetDatabasePermissionsResponses, GetDatabaseQueryData, GetDatabaseQueryError, GetDatabaseQueryErrors, GetDatabaseQueryResponse, GetDatabaseQueryResponses, GetDatabaseResponse, GetDatabaseResponses, GetDatabaseRowHistoryData, GetDatabaseRowHistoryError, GetDatabaseRowHistoryErrors, GetDatabaseRowHistoryResponse, GetDatabaseRowHistoryResponses, GetDatabaseTableChangesData, GetDatabaseTableChangesError, GetDatabaseTableChangesErrors, GetDatabaseTableChangesResponse, GetDatabaseTableChangesResponses, GetDatabaseViewPositionsData, GetDatabaseViewPositionsError, GetDatabaseViewPositionsErrors, GetDatabaseViewPositionsResponse, GetDatabaseViewPositionsResponses, GetDocumentAnchorsData, GetDocumentAnchorsError, GetDocumentAnchorsErrors, GetDocumentAnchorsResponse, GetDocumentAnchorsResponses, GetDocumentBranchNameData, GetDocumentBranchNameError, GetDocumentBranchNameErrors, GetDocumentBranchNameResponse, GetDocumentBranchNameResponses, GetDocumentByTeamSlugData, GetDocumentByTeamSlugError, GetDocumentByTeamSlugErrors, GetDocumentByTeamSlugResponse, GetDocumentByTeamSlugResponses, GetDocumentData, GetDocumentError, GetDocumentErrors, GetDocumentGithubPullRequestsData, GetDocumentGithubPullRequestsError, GetDocumentGithubPullRequestsErrors, GetDocumentGithubPullRequestsResponse, GetDocumentGithubPullRequestsResponses, GetDocumentKeyResponse, GetDocumentKeyResponseData, GetDocumentListHandlerData, GetDocumentListHandlerError, GetDocumentListHandlerErrors, GetDocumentListHandlerResponse, GetDocumentListHandlerResponses, GetDocumentListResult, GetDocumentLocationV3Data, GetDocumentLocationV3Error, GetDocumentLocationV3Errors, GetDocumentLocationV3Response, GetDocumentLocationV3Responses, GetDocumentPermissionsResponseDataV2, GetDocumentPermissionsTokenData, GetDocumentPermissionsTokenError, GetDocumentPermissionsTokenErrors, GetDocumentPermissionsTokenResponse, GetDocumentPermissionsTokenResponses, GetDocumentPermissionsV2Data, GetDocumentPermissionsV2Error, GetDocumentPermissionsV2Errors, GetDocumentPermissionsV2Response, GetDocumentPermissionsV2Responses, GetDocumentProcessingResult, GetDocumentProcessingResultData, GetDocumentProcessingResultError, GetDocumentProcessingResultErrors, GetDocumentProcessingResultResponse, GetDocumentProcessingResultResponse2, GetDocumentProcessingResultResponses, GetDocumentResponse, GetDocumentResponse2, GetDocumentResponseData, GetDocumentResponses, GetDocumentSearchResponse, GetDocumentShortIdData, GetDocumentShortIdError, GetDocumentShortIdErrors, GetDocumentShortIdResponse, GetDocumentShortIdResponses, GetDocumentsResponse, GetDocumentTeamShareData, GetDocumentTeamShareError, GetDocumentTeamShareErrors, GetDocumentTeamShareResponse, GetDocumentTeamShareResponses, GetDocumentTextContentData, GetDocumentTextContentErrors, GetDocumentTextContentResponse, GetDocumentTextContentResponses, GetDocumentUserAccessLevelResponse, GetDocumentVersionData, GetDocumentVersionError, GetDocumentVersionErrors, GetDocumentVersionResponse, GetDocumentVersionResponses, GetDocumentViewsHandlerData, GetDocumentViewsHandlerError, GetDocumentViewsHandlerErrors, GetDocumentViewsHandlerResponse, GetDocumentViewsHandlerResponses, GetEmailFollowupData, GetEmailFollowupError, GetEmailFollowupErrors, GetEmailFollowupResponse, GetEmailFollowupResponses, GetEntityPermissionData, GetEntityPermissionErrors, GetEntityPermissionResponse, GetEntityPermissionResponses, GetForeignEntityBySourceData, GetForeignEntityBySourceError, GetForeignEntityBySourceErrors, GetForeignEntityBySourceResponse, GetForeignEntityBySourceResponses, GetForeignEntityData, GetForeignEntityError, GetForeignEntityErrors, GetForeignEntityResponse, GetForeignEntityResponses, GetFormData, GetFormError, GetFormErrors, GetFormPermissionsData, GetFormPermissionsError, GetFormPermissionsErrors, GetFormPermissionsResponse, GetFormPermissionsResponses, GetFormResponse, GetFormResponses, GetFormResponseSummaryData, GetFormResponseSummaryError, GetFormResponseSummaryErrors, GetFormResponseSummaryResponse, GetFormResponseSummaryResponses, GetFormTallyData, GetFormTallyError, GetFormTallyErrors, GetFormTallyResponse, GetFormTallyResponses, GetGithubPullRequestChangesData, GetGithubPullRequestChangesError, GetGithubPullRequestChangesErrors, GetGithubPullRequestChangesPatchData, GetGithubPullRequestChangesPatchError, GetGithubPullRequestChangesPatchErrors, GetGithubPullRequestChangesPatchResponse, GetGithubPullRequestChangesPatchResponses, GetGithubPullRequestChangesResponse, GetGithubPullRequestChangesResponses, GetGithubPullRequestData, GetGithubPullRequestError, GetGithubPullRequestErrors, GetGithubPullRequestFacetsData, GetGithubPullRequestFacetsError, GetGithubPullRequestFacetsErrors, GetGithubPullRequestFacetsResponse, GetGithubPullRequestFacetsResponses, GetGithubPullRequestResponse, GetGithubPullRequestResponses, GetGithubPullRequestTasksData, GetGithubPullRequestTasksError, GetGithubPullRequestTasksErrors, GetGithubPullRequestTasksResponse, GetGithubPullRequestTasksResponses, GetHarnessPairingData, GetHarnessPairingError, GetHarnessPairingErrors, GetHarnessPairingResponse, GetHarnessPairingResponses, GetHistoryHandlerData, GetHistoryHandlerError, GetHistoryHandlerErrors, GetHistoryHandlerResponse, GetHistoryHandlerResponses, GetInitiativeData, GetInitiativeError, GetInitiativeErrors, GetInitiativeResponse, GetInitiativeResponses, GetInstructionsDocumentResponse, GetInstructionsHandlerData, GetInstructionsHandlerError, GetInstructionsHandlerErrors, GetInstructionsHandlerResponse, GetInstructionsHandlerResponses, GetItemsSoupData, GetItemsSoupError, GetItemsSoupErrors, GetItemsSoupResponse, GetItemsSoupResponses, GetLocationHandlerData, GetLocationHandlerError, GetLocationHandlerErrors, GetLocationHandlerResponse, GetLocationHandlerResponses, GetMyFormResponseData, GetMyFormResponseError, GetMyFormResponseErrors, GetMyFormResponseResponse, GetMyFormResponseResponses, GetOrCreateAction, GetOrCreateCallData, GetOrCreateCallError, GetOrCreateCallErrors, GetOrCreateCallResponse, GetOrCreateCallResponses, GetOrCreateChannelResponse, GetOrCreateDmData, GetOrCreateDmError, GetOrCreateDmErrors, GetOrCreateDmRequest, GetOrCreateDmResponse, GetOrCreateDmResponses, GetOrCreatePrivateData, GetOrCreatePrivateError, GetOrCreatePrivateErrors, GetOrCreatePrivateRequest, GetOrCreatePrivateResponse, GetOrCreatePrivateResponses, GetPendingProjectsHandlerData, GetPendingProjectsHandlerError, GetPendingProjectsHandlerErrors, GetPendingProjectsHandlerResponse, GetPendingProjectsHandlerResponses, GetPinsHandlerData, GetPinsHandlerError, GetPinsHandlerErrors, GetPinsHandlerResponse, GetPinsHandlerResponses, GetPinsResponse, GetProjectContentHandlerData, GetProjectContentHandlerError, GetProjectContentHandlerErrors, GetProjectContentHandlerResponse, GetProjectContentHandlerResponses, GetProjectContentResponse, GetProjectHandlerData, GetProjectHandlerError, GetProjectHandlerErrors, GetProjectHandlerResponse, GetProjectHandlerResponses, GetProjectPermissionsV2Data, GetProjectPermissionsV2Error, GetProjectPermissionsV2Errors, GetProjectPermissionsV2Response, GetProjectPermissionsV2Responses, GetProjectResponse, GetProjectResponseData, GetProjectsHandlerData, GetProjectsHandlerError, GetProjectsHandlerErrors, GetProjectsHandlerResponse, GetProjectsHandlerResponses, GetProjectsResponse, GetProjectUserAccessLevelData, GetProjectUserAccessLevelError, GetProjectUserAccessLevelErrors, GetProjectUserAccessLevelResponse, GetProjectUserAccessLevelResponses, GetRingStatusData, GetRingStatusError, GetRingStatusErrors, GetRingStatusResponse, GetRingStatusResponses, GetSelfBotData, GetSelfBotError, GetSelfBotErrors, GetSelfBotResponse, GetSelfBotResponses, GetSelfHarnessData, GetSelfHarnessError, GetSelfHarnessErrors, GetSelfHarnessResponse, GetSelfHarnessResponses, GetSlackImportData, GetSlackImportErrors, GetSlackImportResponse, GetSlackImportResponses, GetSystemSkillsHandlerData, GetSystemSkillsHandlerError, GetSystemSkillsHandlerErrors, GetSystemSkillsHandlerResponse, GetSystemSkillsHandlerResponses, GetUserDocumentsHandlerData, GetUserDocumentsHandlerError, GetUserDocumentsHandlerErrors, GetUserDocumentsHandlerResponse, GetUserDocumentsHandlerResponses, GetUserDocumentViewLocationData, GetUserDocumentViewLocationError, GetUserDocumentViewLocationErrors, GetUserDocumentViewLocationResponse, GetUserDocumentViewLocationResponses, GetUserHistoryResponse, GetViewsHandlerData, GetViewsHandlerError, GetViewsHandlerErrors, GetViewsHandlerResponse, GetViewsHandlerResponses, GetWebhookData, GetWebhookError, GetWebhookErrors, GetWebhookResponse, GetWebhookResponses, GithubLabelFacet, GithubPullRequest, GithubPullRequestChangesPatchResponse, GithubPullRequestChangesResponse, GithubPullRequestCheckRun, GithubPullRequestComment, GithubPullRequestFacets, GithubPullRequestLabel, GithubPullRequestReview, GithubPullRequestReviewDecision, GithubPullRequestReviewState, GithubPullRequestsResponse, GithubPullRequestTasks, GithubPullRequestTasksRequest, GithubPullRequestTasksResponse, GithubPullRequestUser, GithubRepositoryFacet, GithubUserFacet, GitRefDto, GroupedInitialParams, GroupedPageParams, GroupedSoupGroupPage, GroupedSoupInitialPage, GroupedSoupPage, GroupedSoupSort, GuestCallChatPostData, GuestCallChatPostErrors, GuestCallChatPostResponse, GuestCallChatPostResponses, GuestCallChatReadData, GuestCallChatReadErrors, GuestCallChatReadResponse, GuestCallChatReadResponses, GuestChatMessage, GuestChatPage, GuestChatPost, GuestId, GuestJoinRequest, GuestPolicy, HandlerData, HandlerError, HandlerErrors, HandlerResponse, HandlerResponses, Harness, HarnessAgent, HarnessId, HarnessOwner, HarnessSession, HashMap, HealthHandlerData, HealthHandlerResponse, HealthHandlerResponses, HighlightType, ImportCounters, ImportDatabaseTableData, ImportDatabaseTableError, ImportDatabaseTableErrors, ImportDatabaseTableResponse, ImportDatabaseTableResponses, ImportedAuthor, ImportError, ImportLimits, ImportPage, ImportProgress, ImportTable, ImportWarning, InferColumnTypeOutcome, InferColumnTypeRequest, InferDatabaseColumnTypeData, InferDatabaseColumnTypeError, InferDatabaseColumnTypeErrors, InferDatabaseColumnTypeResponse, InferDatabaseColumnTypeResponses, InFlightTurnSummary, IngestTranscriptData, IngestTranscriptError, IngestTranscriptErrors, IngestTranscriptResponses, InitializeUserDocumentsData, InitializeUserDocumentsError, InitializeUserDocumentsErrors, InitializeUserDocumentsResponse, InitializeUserDocumentsResponses, InitialPropertyValue, InitiativeDetail, InitiativeFilters, InitiativeId, InitiativeList, InitiativeSummary, InputReceivedMetadata, InstallSyncData, InstallSyncErrors, InteractionReason, InvalidDatabaseWebhookPayloadResponse, InviteMeetingRequest, InviteMeetingUsersRequest, Item, ItemWithUserAccessLevel, JobId, JobProcessingResultHandlerData, JobProcessingResultHandlerError, JobProcessingResultHandlerErrors, JobProcessingResultHandlerResponse, JobProcessingResultHandlerResponses, JobStatus, JoinChannelByCodeData, JoinChannelByCodeError, JoinChannelByCodeErrors, JoinChannelByCodeResponses, JoinChannelData, JoinChannelError, JoinChannelErrors, JoinChannelResponses, KeySegment, Lane, LaneKey, LatestMessage, LayoutProblem, LeaveCallResponse, LeaveChannelData, LeaveChannelError, LeaveChannelErrors, LeaveChannelResponses, LeaveOrEndCallData, LeaveOrEndCallError, LeaveOrEndCallErrors, LeaveOrEndCallResponse, LeaveOrEndCallResponses, LinkShare, ListAccessibleFormsData, ListAccessibleFormsError, ListAccessibleFormsErrors, ListAccessibleFormsResponse, ListAccessibleFormsResponses, ListAgentsData, ListAgentsError, ListAgentsErrors, ListAgentsResponse, ListAgentsResponses, ListBotChannelsData, ListBotChannelsError, ListBotChannelsErrors, ListBotChannelsResponse, ListBotChannelsResponses, ListChannelLabelsData, ListChannelLabelsError, ListChannelLabelsErrors, ListChannelLabelsResponse, ListChannelLabelsResponses, ListCompanyContactsData, ListCompanyContactsError, ListCompanyContactsErrors, ListCompanyContactsResponse, ListCompanyContactsResponses, ListCrmBlockedDomainsData, ListCrmBlockedDomainsError, ListCrmBlockedDomainsErrors, ListCrmBlockedDomainsResponse, ListCrmBlockedDomainsResponses, ListCrmPipelinesData, ListCrmPipelinesResponse, ListCrmPipelinesResponses, ListDatabaseColumnCastsData, ListDatabaseColumnCastsError, ListDatabaseColumnCastsErrors, ListDatabaseColumnCastsResponse, ListDatabaseColumnCastsResponses, ListDatabasesData, ListDatabasesError, ListDatabasesErrors, ListDatabasesResponse, ListDatabasesResponses, ListDatabaseWebhooksData, ListDatabaseWebhooksError, ListDatabaseWebhooksErrors, ListDatabaseWebhooksResponse, ListDatabaseWebhooksResponse2, ListDatabaseWebhooksResponses, ListedDatabase, ListedForm, ListEmailRemindersData, ListEmailRemindersError, ListEmailRemindersErrors, ListEmailRemindersResponse, ListEmailRemindersResponses, ListFavoritesData, ListFavoritesError, ListFavoritesErrors, ListFavoritesResponse, ListFavoritesResponses, ListFormsData, ListFormsError, ListFormsErrors, ListFormsResponse, ListFormsResponses, ListHarnessAgentsData, ListHarnessAgentsError, ListHarnessAgentsErrors, ListHarnessAgentsResponse, ListHarnessAgentsResponses, ListHarnessesData, ListHarnessesError, ListHarnessesErrors, ListHarnessesResponse, ListHarnessesResponses, ListHarnessSessionsData, ListHarnessSessionsError, ListHarnessSessionsErrors, ListHarnessSessionsResponse, ListHarnessSessionsResponses, ListInitiativesData, ListInitiativesError, ListInitiativesErrors, ListInitiativesResponse, ListInitiativesResponses, ListJoinRequestsData, ListJoinRequestsError, ListJoinRequestsErrors, ListJoinRequestsResponse, ListJoinRequestsResponses, ListOccurrencesData, ListOccurrencesErrors, ListOccurrencesResponse, ListOccurrencesResponses, ListSlackImportsData, ListSlackImportsResponse, ListSlackImportsResponses, ListTeamCalendarData, ListTeamCalendarResponse, ListTeamCalendarResponses, ListTeamOutOfOfficeData, ListTeamOutOfOfficeErrors, ListTeamOutOfOfficeResponse, ListTeamOutOfOfficeResponses, ListUserApiKeysData, ListUserApiKeysError, ListUserApiKeysErrors, ListUserApiKeysResponse, ListUserApiKeysResponses, ListWebhooksData, ListWebhooksError, ListWebhooksErrors, ListWebhooksResponse, ListWebhooksResponse2, ListWebhooksResponses, LocationResponseData, LocationResponseV3, MacroUserIdStr, MarkRead, Meeting, MeetingCancelData, MeetingCancelError, MeetingCancelErrors, MeetingCancelPreparationData, MeetingCancelPreparationError, MeetingCancelPreparationErrors, MeetingCancelPreparationResponse, MeetingCancelPreparationResponses, MeetingCancelResponse, MeetingCancelResponses, MeetingCreateData, MeetingCreateError, MeetingCreateErrors, MeetingCreateResponse, MeetingCreateResponses, MeetingGuestJoinData, MeetingGuestJoinError, MeetingGuestJoinErrors, MeetingGuestJoinResponse, MeetingGuestJoinResponses, MeetingGuestParticipantsData, MeetingGuestParticipantsError, MeetingGuestParticipantsErrors, MeetingGuestParticipantsResponse, MeetingGuestParticipantsResponses, MeetingInviteData, MeetingInviteError, MeetingInviteErrors, MeetingInvitePermissions, MeetingInvitePermissionsData, MeetingInvitePermissionsError, MeetingInvitePermissionsErrors, MeetingInvitePermissionsResponse, MeetingInvitePermissionsResponses, MeetingInviteResponse, MeetingInviteResponses, MeetingInviteUsersData, MeetingInviteUsersError, MeetingInviteUsersErrors, MeetingInviteUsersResponse, MeetingInviteUsersResponses, MeetingJoinData, MeetingJoinError, MeetingJoinErrors, MeetingJoinResponse, MeetingJoinResponses, MeetingLeaveData, MeetingLeaveError, MeetingLeaveErrors, MeetingLeaveResponse, MeetingLeaveResponses, MeetingListActiveData, MeetingListActiveError, MeetingListActiveErrors, MeetingListActiveResponse, MeetingListActiveResponses, MeetingListData, MeetingListError, MeetingListErrors, MeetingListResponse, MeetingListResponses, MeetingLookupData, MeetingLookupError, MeetingLookupErrors, MeetingLookupResponse, MeetingLookupResponses, MeetingParticipant, MeetingParticipants, MeetingParticipantsData, MeetingParticipantsError, MeetingParticipantsErrors, MeetingParticipantsResponse, MeetingParticipantsResponses, MeetingPreparation, MeetingPrepareData, MeetingPrepareError, MeetingPrepareErrors, MeetingPrepareResponse, MeetingPrepareResponses, MeetingShareData, MeetingShareError, MeetingShareErrors, MeetingShareResponse, MeetingShareResponses, MeetingsResponse, MeetingToken, MeetingUpdateData, MeetingUpdateError, MeetingUpdateErrors, MeetingUpdateResponse, MeetingUpdateResponses, MentionPreviewsData, MentionPreviewsErrors, MentionPreviewsResponse, MentionPreviewsResponses, Message, MessageAttachment, MessageAttachmentCreatedMetadata, MessageAttachmentRemovedMetadata, MessageChange, MessageCursor, MessageDeletedMetadata, MessageDirection, MessageEvent, MessageEventAttachment, MessageListItem, MessageMentionedMetadata, MessagePage, MessageParent, MessagePatch, MessagePatchedMetadata, MessagePostedMetadata, MessageThread, MessageThreadPreview, MessageTimelineData, MessageTimelineEntriesData, MessageTimelineEntriesResponse, MessageTimelineEntriesResponses, MessageTimelineEntry, MessageTimelinePage, MessageTimelineQuery, MessageTimelineResponse, MessageTimelineResponses, MessageTopicEvent, MyResponse, NewAttachment, NewColumn, NewOption, NewThreadAnchor, NewView, NotificationFilters, NotificationState, NumberOperator, OpBatch, Operator, OpRefusalResponse, OpResult, OptionId, OptionRef, PairingDetails, Params, ParticipantRole, PatchBotRequest, PatchChannelData, PatchChannelError, PatchChannelErrors, PatchChannelRequest, PatchChannelResponse, PatchChannelResponses, PatchMessageNotificationPolicy, PatchProjectRequestV2, PatchThreadRequestV2, PatchViewHandlerData, PatchViewHandlerError, PatchViewHandlerErrors, PatchViewHandlerResponses, PatchWebhookData, PatchWebhookError, PatchWebhookErrors, PatchWebhookRequest, PatchWebhookResponse, PatchWebhookResponses, PdfAnchor, PdfAnchorId, PdfHighlightAnchor, PdfHighlightAnchorRequest, PdfHighlightRect, PdfHighlightRectAnchorRequest, PdfPlaceableCommentAnchor, PendingClaimResponse, PermanentlyDeleteDocumentData, PermanentlyDeleteDocumentError, PermanentlyDeleteDocumentErrors, PermanentlyDeleteDocumentResponse, PermanentlyDeleteDocumentResponses, PermanentlyDeleteProjectData, PermanentlyDeleteProjectError, PermanentlyDeleteProjectErrors, PermanentlyDeleteProjectResponse, PermanentlyDeleteProjectResponses, PinnedItem, PinRequest, Pipeline, PipelineRecordType, PipelineSharing, PostActivityData, PostActivityError, PostActivityErrors, PostActivityRequest, PostActivityResponse, PostActivityResponses, PostChannelBotWebhookData, PostChannelBotWebhookError, PostChannelBotWebhookErrors, PostChannelBotWebhookResponse, PostChannelBotWebhookResponses, PostGroupedSoupAstGroupPageRequest, PostGroupedSoupAstInitialRequest, PostGroupedSoupAstRequest, PostItemsSoupAstData, PostItemsSoupAstError, PostItemsSoupAstErrors, PostItemsSoupAstGroupedData, PostItemsSoupAstGroupedError, PostItemsSoupAstGroupedErrors, PostItemsSoupAstGroupedResponse, PostItemsSoupAstGroupedResponses, PostItemsSoupAstResponse, PostItemsSoupAstResponses, PostItemsSoupData, PostItemsSoupError, PostItemsSoupErrors, PostItemsSoupResponse, PostItemsSoupResponses, PostMessage, PostMessageNotificationPolicy, PostSoupAstRequest, PostSoupRequest, PresaveDocumentHandlerData, PresaveDocumentHandlerError, PresaveDocumentHandlerErrors, PresaveDocumentHandlerResponse, PresaveDocumentHandlerResponses, PreSaveDocumentRequest, PreSaveDocumentResponse, PreSaveDocumentResponseData, PresenceOperator, PresignedUrl, PreviewSmartTagData, PreviewSmartTagError, PreviewSmartTagErrors, PreviewSmartTagResponse, PreviewSmartTagResponses, Project, ProjectDeleteResponseData, ProjectDocumentStatus, ProjectFilters, ProjectPreview, ProjectPreviewData, PropertyBucketing, PropertyDateFilterRange, PropertyDateRange, PropertyDateRanges, PropertyDefinition, PropertyDefinitionWithOptions, PropertyFilter, PropertyInput, PropertyOption, PropertyOptionValue, PropertyOwner, PropertyValue, PutCrmTeamSettingsData, PutCrmTeamSettingsError, PutCrmTeamSettingsErrors, PutCrmTeamSettingsResponse, PutCrmTeamSettingsResponses, PutCrmTeamStagesData, PutCrmTeamStagesError, PutCrmTeamStagesErrors, PutCrmTeamStagesResponse, PutCrmTeamStagesResponses, PutFormLayoutData, PutFormLayoutError, PutFormLayoutErrors, PutFormLayoutResponse, PutFormLayoutResponses, QueryCrmPipelineRowsData, QueryCrmPipelineRowsResponse, QueryCrmPipelineRowsResponses, QueryDatabasesData, QueryDatabasesError, QueryDatabasesErrors, QueryDatabasesResponse, QueryDatabasesResponses, QueryDefinition, QuestionLayout, QuestionOption, QuestionTally, ReactionInput, RecentlyDeletedData, RecentlyDeletedError, RecentlyDeletedErrors, RecentlyDeletedResponse, RecentlyDeletedResponseData, RecentlyDeletedResponses, RegisterSlackImportUploadsData, RegisterSlackImportUploadsErrors, RegisterSlackImportUploadsResponse, RegisterSlackImportUploadsResponses, RegisterUploads, RemoveBotFromChannelByBotData, RemoveBotFromChannelByBotError, RemoveBotFromChannelByBotErrors, RemoveBotFromChannelByBotResponse, RemoveBotFromChannelByBotResponses, RemoveFavoriteByEntityData, RemoveFavoriteByEntityError, RemoveFavoriteByEntityErrors, RemoveFavoriteByEntityResponses, RemoveParticipantsData, RemoveParticipantsError, RemoveParticipantsErrors, RemoveParticipantsRequest, RemoveParticipantsResponses, RemovePinHandlerData, RemovePinHandlerError, RemovePinHandlerErrors, RemovePinHandlerResponse, RemovePinHandlerResponses, RenameChannelLabelData, RenameChannelLabelError, RenameChannelLabelErrors, RenameChannelLabelRequest, RenameChannelLabelResponse, RenameChannelLabelResponses, RenameCrmPipelineData, RenameCrmPipelineResponse, RenameCrmPipelineResponses, RenamePipeline, ReorderFavoritesData, ReorderFavoritesError, ReorderFavoritesErrors, ReorderFavoritesRequest, ReorderFavoritesResponses, ReorderPinRequest, ReorderPinsHandlerData, ReorderPinsHandlerError, ReorderPinsHandlerErrors, ReorderPinsHandlerResponse, ReorderPinsHandlerResponses, ReplaceCrmStagesRequest, RequestAccess, RequestedHarnessScope, RequestedLayout, RequestStatus, RequestToJoinData, RequestToJoinError, RequestToJoinErrors, RequestToJoinResponse, RequestToJoinResponses, ResetCrmTeamStagesData, ResetCrmTeamStagesError, ResetCrmTeamStagesErrors, ResetCrmTeamStagesResponse, ResetCrmTeamStagesResponses, ResolveRequest, ResponseStatus, ResponseSummary, ResultColumn, ResultSet, RevertDeleteDocumentData, RevertDeleteDocumentError, RevertDeleteDocumentErrors, RevertDeleteDocumentResponse, RevertDeleteDocumentResponses, RevertDeleteProjectData, RevertDeleteProjectError, RevertDeleteProjectErrors, RevertDeleteProjectResponse, RevertDeleteProjectResponses, RingStatus, RingStatusResponse, RowChange, RowChangeKind, RowChanges, RowHistoryEntry, RowHistoryResponse, RowId, RowsChange, RowsResult, S3ObjectInfo, SaveBomPart, SaveDatabaseQueryData, SaveDatabaseQueryError, SaveDatabaseQueryErrors, SaveDatabaseQueryResponse, SaveDatabaseQueryResponses, SaveDocumentHandlerData, SaveDocumentHandlerError, SaveDocumentHandlerErrors, SaveDocumentHandlerResponse, SaveDocumentHandlerResponses, SaveDocumentRequest, SaveDocumentResponse, SaveDocumentResponseData, SavedQuery, SaveQueryRequest, SearchContactsData, SearchContactsError, SearchContactsErrors, SearchContactsResponse, SearchContactsResponse2, SearchContactsResponses, SearchState, SectionCount, SessionDeletedMetadata, SessionIdentity, SessionMentionedMetadata, SessionOpenedMetadata, SessionRenamedMetadata, SessionSettledMetadata, SessionSource, SessionStoppedMetadata, SetChannelLabelData, SetChannelLabelError, SetChannelLabelErrors, SetChannelLabelRequest, SetChannelLabelResponse, SetChannelLabelResponses, SetChannelPictureData, SetChannelPictureError, SetChannelPictureErrors, SetChannelPictureRequest, SetChannelPictureResponse, SetChannelPictureResponses, SetCompanyHiddenData, SetCompanyHiddenError, SetCompanyHiddenErrors, SetCompanyHiddenRequest, SetCompanyHiddenResponse, SetCompanyHiddenResponses, SetCompanyNameRequest, SetContactHiddenData, SetContactHiddenError, SetContactHiddenErrors, SetContactHiddenRequest, SetContactHiddenResponse, SetContactHiddenResponses, SetContactNameRequest, SetCrmCompanyNameData, SetCrmCompanyNameError, SetCrmCompanyNameErrors, SetCrmCompanyNameResponse, SetCrmCompanyNameResponses, SetCrmContactNameData, SetCrmContactNameError, SetCrmContactNameErrors, SetCrmContactNameResponse, SetCrmContactNameResponses, SetDirectAccess, SetDocumentTeamShareData, SetDocumentTeamShareError, SetDocumentTeamShareErrors, SetDocumentTeamShareRequest, SetDocumentTeamShareResponse, SetDocumentTeamShareResponses, SetEmailFollowupData, SetEmailFollowupError, SetEmailFollowupErrors, SetEmailFollowupResponse, SetEmailFollowupResponses, SetEmailSyncData, SetEmailSyncError, SetEmailSyncErrors, SetEmailSyncRequest, SetEmailSyncResponse, SetEmailSyncResponses, SetOperator, SetPropertyValue, Sha256Digest, ShareCrmPipelineData, ShareCrmPipelineResponse, ShareCrmPipelineResponses, ShareDatabaseAwarenessData, ShareDatabaseAwarenessError, ShareDatabaseAwarenessErrors, ShareDatabaseAwarenessResponse, ShareDatabaseAwarenessResponses, SharedEmailFilter, SharedExternalChatReference, ShareEntity, ShareEntityType, SharePermissionV2, SharePipeline, ShortIdResponse, SimpleMention, SimpleSaveData, SimpleSaveError, SimpleSaveErrors, SimpleSaveResponse, SimpleSaveResponses, SkippedCell, SlackCompleteRequest, SlackCreateRequest, SlackRegisterRequest, SlackTimestamp, SlackUserId, SmartTagChannelMatch, SmartTagPreview, SortDirection, SortKey, SoupAgentSessionSoupPropertiesField, SoupApiItem, SoupApiSort, SoupApiSortDirection, SoupAttachment, SoupCalendarEventSoupPropertiesField, SoupCalendarEventTime, SoupCallRecordGuest, SoupCallRecordParticipant, SoupCallRecordSoupPropertiesField, SoupChannel, SoupChannelThread, SoupChatSoupPropertiesField, SoupContact, SoupCountedReaction, SoupCrmCompanySoupPropertiesField, SoupCrmContactSoupPropertiesField, SoupCrmDomain, SoupDatabaseRowSoupPropertiesField, SoupDocumentSoupPropertiesField, SoupDocumentSubType, SoupEmailThreadPreview, SoupEnrichedEmailThreadPreviewSoupPropertiesField, SoupForeignEntity, SoupInitiativeSoupPropertiesField, SoupItem, SoupLabel, SoupLabelListVisibility, SoupLabelType, SoupMessageAttachment, SoupMessageListVisibility, SoupMessageSender, SoupMessageSenderType, SoupPage, SoupProjectSoupPropertiesField, SoupPropertiesField, SoupProperty, SoupThreadInfo, SoupThreadReply, SourceBinding, SourceId, SourceIdentity, SqlCell, SqlEntityKind, SqlOutcome, SqlOutcomeKind, SqlSelectOption, SqlStatement, StarterDatabase, StarterDocumentsResponse, StorageRow, StorageRows, StorageRowsQuery, StoredGithubPullRequest, StreamEventsData, StreamEventsError, StreamEventsErrors, StreamEventsResponse, StreamEventsResponses, String, Submission, SubmissionOutcome, SubmitFormResponseData, SubmitFormResponseError, SubmitFormResponseErrors, SubmitFormResponseResponse, SubmitFormResponseResponses, SuccessResponse, SurfaceState, SyncServiceVersionId, SystemSkillSummary, Table, TableChange, TableChanged, TableChanges, TableDetail, TableId, TableResult, TableVersion, TagFilterMode, TakenId, TallyBucket, TallyValue, TaskFilters, TaskSimilarityResult, TaskSimilaritySearchHandlerData, TaskSimilaritySearchHandlerError, TaskSimilaritySearchHandlerErrors, TaskSimilaritySearchHandlerResponse, TaskSimilaritySearchHandlerResponses, TaskSimilaritySearchRequest, TaskSimilaritySearchResponse, TeamCalendarContent, TeamCalendarCoverage, TeamCalendarDetails, TeamCalendarItem, TeamCalendarMember, TeamCalendarPage, TeamCalendarSharing, TeamOutOfOfficeItem, TeamOutOfOfficeResponse, TeamRole, TextOperator, ThreadAnchor, ThreadOrigin, ThreadPatch, ThreadState, TimelineActivity, ToggleShareWithTeamData, ToggleShareWithTeamError, ToggleShareWithTeamErrors, ToggleShareWithTeamResponse, ToggleShareWithTeamResponses, TouchedColumn, TouchedRow, TranscribeDictationData, TranscribeDictationError, TranscribeDictationErrors, TranscribeDictationResponse, TranscribeDictationResponses, TranscribeResponse, TranscriptSegmentRequest, TrashCrmPipelineData, TrashCrmPipelineResponse, TrashCrmPipelineResponses, TrashPipeline, TurnEndedMetadata, TurnStartedMetadata, TurnSummary, TypedSuccessResponse, TypedSuccessResponseGetDocumentResponseData, TypingInput, UnblockCrmDomainData, UnblockCrmDomainError, UnblockCrmDomainErrors, UnblockCrmDomainResponse, UnblockCrmDomainResponses, UndoChangeResponse, UndoDatabaseChangeData, UndoDatabaseChangeError, UndoDatabaseChangeErrors, UndoDatabaseChangeResponse, UndoDatabaseChangeResponses, UndoOutcome, UndoRefusal, UnlockedBooking, UpdateAgentData, UpdateAgentError, UpdateAgentErrors, UpdateAgentRequest, UpdateAgentResponse, UpdateAgentResponses, UpdateChannelSharePermission, UpdateCrmPipelinePermissionsData, UpdateCrmPipelinePermissionsResponse, UpdateCrmPipelinePermissionsResponses, UpdateCrmTeamSettingsRequest, UpdateDatabasePermissionsData, UpdateDatabasePermissionsError, UpdateDatabasePermissionsErrors, UpdateDatabasePermissionsResponse, UpdateDatabasePermissionsResponses, UpdateForm, UpdateFormData, UpdateFormError, UpdateFormErrors, UpdateFormPermissionsData, UpdateFormPermissionsError, UpdateFormPermissionsErrors, UpdateFormPermissionsResponse, UpdateFormPermissionsResponses, UpdateFormResponse, UpdateFormResponses, UpdateInitiativeData, UpdateInitiativeError, UpdateInitiativeErrors, UpdateInitiativeRequest, UpdateInitiativeResponse, UpdateInitiativeResponses, UpdateMeetingRequest, UpdateOperation, UpdateSharePermissionRequestV2, UploadDescriptor, UploadDocumentStatus, UploadExtractFolderHandlerData, UploadExtractFolderHandlerError, UploadExtractFolderHandlerErrors, UploadExtractFolderHandlerResponse, UploadExtractFolderHandlerResponses, UploadExtractFolderRequest, UploadFolderHandlerData, UploadFolderHandlerError, UploadFolderHandlerErrors, UploadFolderHandlerResponse, UploadFolderHandlerResponses, UploadFolderRequest, UploadGrant, UploadId, UpsertHistoryHandlerData, UpsertHistoryHandlerError, UpsertHistoryHandlerErrors, UpsertHistoryHandlerResponse, UpsertHistoryHandlerResponses, UpsertUserDocumentViewLocationData, UpsertUserDocumentViewLocationError, UpsertUserDocumentViewLocationErrors, UpsertUserDocumentViewLocationRequest, UpsertUserDocumentViewLocationResponse, UpsertUserDocumentViewLocationResponses, UserApiKeyId, UserApiKeyInfo, UserApiKeysList, UserDocumentsResponse, UserDocumentViewLocation, UserDocumentViewLocationResponse, UserPinsResponse, UserViewsResponse, ValidateDocumentPermissionsTokenData, ValidateDocumentPermissionsTokenError, ValidateDocumentPermissionsTokenErrors, ValidateDocumentPermissionsTokenResponse, ValidateDocumentPermissionsTokenResponses, ValidateWebhookData, ValidateWebhookError, ValidateWebhookErrors, ValidateWebhookResponse, ValidateWebhookResponse2, ValidateWebhookResponses, Vec, VersionedTable, View, ViewChange, ViewColumn, ViewerCapabilities, ViewLayout, ViewPatch, ViewPosition, ViewPositionsResponse, ViewQuery, ViewResult, ViewsResponse, WaitingForInputMetadata, Webhook, WebhookEvent, WebhookFilter, WebhookScope, WebhookStatus, WebhookValidationTestEvent, WhatsAppAccount, WhatsappAccountData, WhatsappAccountResponse, WhatsappAccountResponses, WhatsAppAccountState, WhatsAppAccountView, WhatsappCancelPairingData, WhatsappCancelPairingResponse, WhatsappCancelPairingResponses, WhatsAppCannotAdd, WhatsAppChat, WhatsAppChats, WhatsappChatsData, WhatsappChatsResponse, WhatsappChatsResponses, WhatsAppConnect, WhatsappConnectData, WhatsappConnectResponse, WhatsappConnectResponses, WhatsAppDisconnect, WhatsappDisconnectData, WhatsAppDisconnectRequest, WhatsappDisconnectResponse, WhatsappDisconnectResponses, WhatsAppHistoryImport, WhatsappImportHistoryData, WhatsappImportHistoryResponse, WhatsappImportHistoryResponses, WhatsAppLookup, WhatsappLookupData, WhatsAppLookupRequest, WhatsappLookupResponse, WhatsappLookupResponses, WhatsAppLookupState, WhatsAppPairing, WhatsappPairingData, WhatsappPairingResponse, WhatsappPairingResponses, WhatsAppPairingState, WhatsAppPairState, WhatsappPasskeyData, WhatsappPasskeyResponse, WhatsappPasskeyResponses, WhatsappStartLookupData, WhatsappStartLookupResponse, WhatsappStartLookupResponses, Widget, WithCallId, WithChannelId, WithDocumentId, WithProjectId } from './types.gen';+export type { AccentColor, AccessiblePipeline, AccessLevel, AccessRequest, AccessRequestsCancelData, AccessRequestsCancelErrors, AccessRequestsCancelResponses, AccessRequestsDirectData, AccessRequestsDirectErrors, AccessRequestsDirectResponse, AccessRequestsDirectResponses, AccessRequestsRemoveDirectData, AccessRequestsRemoveDirectErrors, AccessRequestsRemoveDirectResponses, AccessRequestsResolveData, AccessRequestsResolveErrors, AccessRequestsResolveResponse, AccessRequestsResolveResponses, AccessRequestsSetDirectData, AccessRequestsSetDirectErrors, AccessRequestsSetDirectResponses, AccessRequestsStateData, AccessRequestsStateErrors, AccessRequestsStateResponse, AccessRequestsStateResponses, AccessRequestsSubmitData, AccessRequestsSubmitErrors, AccessRequestsSubmitResponse, AccessRequestsSubmitResponses, AccessRequestState, ActiveCallsResponse, ActiveCallSummary, ActiveMeeting, ActiveMeetingsResponse, ActivityType, AddFavoriteData, AddFavoriteError, AddFavoriteErrors, AddFavoriteRequest, AddFavoriteResponse, AddFavoriteResponses, AddParticipantsData, AddParticipantsError, AddParticipantsErrors, AddParticipantsRequest, AddParticipantsResponses, AddPinHandlerData, AddPinHandlerError, AddPinHandlerErrors, AddPinHandlerResponse, AddPinHandlerResponses, AddPinRequest, Agent, AgentActionId, AgentChannelScope, AgentDmProfile, AgentMcpServer, AgentMcpServers, AgentPullRequestState, AgentSessionArchiveCause, AgentSessionFilters, AgentSessionLifecycleEvent, AgentSessionSource, AgentSessionVisibility, AgentTyping, AgentTypingPhase, AiAdmissionErrorBody, Anchor, AnchorId, AnchorResponse, AnnotationIncrementalUpdate, Answer, ApiActivity, ApiAttachmentChannelReference, ApiAttachmentCommentReference, ApiAttachmentEntityReference, ApiAttachmentGenericReference, ApiChannelAttachment, ApiChannelAttachmentsPage, ApiChannelDetail, ApiChannelListMessage, ApiChannelListPage, ApiChannelListParticipant, ApiChannelListType, ApiChannelParticipant, ApiChannelWithLatest, ApiEntityFilterAst, ApiGroupByField, ApiGroupMeta, ApiParticipantListRole, ApiParticipantRole, ApiPropertyEntityType, AppliedOps, ApplyCrmPipelineOpsData, ApplyCrmPipelineOpsResponse, ApplyCrmPipelineOpsResponses, ApplyDatabaseOpsData, ApplyDatabaseOpsError, ApplyDatabaseOpsErrors, ApplyDatabaseOpsResponse, ApplyDatabaseOpsResponses, ApplyOpsRequest, ApplyOpsResponse, ApproveHarnessPairingData, ApproveHarnessPairingError, ApproveHarnessPairingErrors, ApproveHarnessPairingResponse, ApproveHarnessPairingResponses, ApprovePairingRequest, AttachmentChange, AttendeeResponseStatus, Audience, Awareness, AwarenessRelay, BasicDocument, BasicDocumentSubType, BlockCrmDomainData, BlockCrmDomainError, BlockCrmDomainErrors, BlockCrmDomainResponse, BlockCrmDomainResponses, BomPart, BookingTarget, Bot, BotChannel, BotChannelType, BotId, BotKind, BotOwner, BotOwnerProfile, BotSenderProfile, BotToken, BranchNameResponse, BTreeMap, BulkWakeupRequest, BulkWakeupResponse, BulkWakeupSyncServiceDocumentsData, BulkWakeupSyncServiceDocumentsErrors, BulkWakeupSyncServiceDocumentsResponse, BulkWakeupSyncServiceDocumentsResponses, CalendarAttendee, CalendarEvent, CalendarEventFilters, CalendarEventSourceContent, CalendarJoinRequest, CalendarJoinRequestApiError, CalendarJoinRequestErrorCode, CalendarJoinRequestsResponse, CalendarJoinRequestStatus, CalendarMentionEvent, CalendarMentionPreviewItem, CalendarMentionPreviewKind, CalendarMentionPreviewRequest, CalendarMentionPreviewRequestItem, CalendarMentionPreviewResponse, CalendarMentionViewerCopy, CalendarOccurrence, CalendarOccurrenceItem, CalendarOccurrenceResponse, CalendarSyncStatus, CallActiveResponse, CallFilters, CallProvider, CallRecord, CallRecordGuest, CallRecordParticipant, CallRecordPreview, CallRecordPreviewData, CallRecordSource, CallRecordTranscriptSegment, CallStatus, CallTokenResponse, CallWebhookData, CallWebhookError, CallWebhookErrors, CallWebhookResponses, CancelSlackImportData, CancelSlackImportErrors, CancelSlackImportResponse, CancelSlackImportResponses, CardPosition, CastVerdict, CellValue, CellWrite, ChangedFileDto, ChangesetDto, ChangesetSourceDto, Channel, ChannelCreatedMetadata, ChannelDeletedMetadata, ChannelFilters, ChannelJoinCodeResponse, ChannelLabel, ChannelLabelRule, ChannelLabelScopeSelection, ChannelLabelsList, ChannelMessage, ChannelParticipant, ChannelParticipantAddedMetadata, ChannelParticipantRemovedMetadata, ChannelPictureChangedMetadata, ChannelPreview, ChannelPreviewData, ChannelSender, ChannelSharePermission, ChannelThreadFilters, ChannelTopicEvent, ChannelType, ChannelUpdatedMetadata, ChannelWebhookRequest, ChannelWebhookResponse, ChannelWithParticipants, Chat, ChatFilters, CheckActiveCallData, CheckActiveCallError, CheckActiveCallErrors, CheckActiveCallResponse, CheckActiveCallResponses, ClaimedPairing, ClaimHarnessPairingData, ClaimHarnessPairingError, ClaimHarnessPairingErrors, ClaimHarnessPairingResponse, ClaimHarnessPairingResponses, ClaimPairingRequest, ClientOptions, CloudStorageItemType, CollaborateFormData, CollaborateFormError, CollaborateFormErrors, CollaborateFormResponse, CollaborateFormResponses, CollabSurfaceResponse, CollabSurfaceTokenResponse, Column, ColumnCast, ColumnChange, ColumnChangeKind, ColumnConfig, ColumnConversion, ColumnConversionRequest, ColumnDetail, ColumnId, ColumnKind, ColumnProtection, ColumnResult, CommandFailure, CommandRejectedMetadata, CommittedChange, CompleteSlackImportUploadsData, CompleteSlackImportUploadsErrors, CompleteSlackImportUploadsResponse, CompleteSlackImportUploadsResponses, CompleteUploads, ConferenceProvider, Conjunction, ConversationId, ConversationKind, ConversationMetadata, ConversationProgress, ConversationSeal, ConversationStatus, ConvertDatabaseColumnData, ConvertDatabaseColumnError, ConvertDatabaseColumnErrors, ConvertDatabaseColumnResponse, ConvertDatabaseColumnResponses, ConvertedCell, CopyDocumentData, CopyDocumentError, CopyDocumentErrors, CopyDocumentQueryParams, CopyDocumentRequest, CopyDocumentResponse, CopyDocumentResponse2, CopyDocumentResponses, CountedReaction, CreateAgentData, CreateAgentError, CreateAgentErrors, CreateAgentRequest, CreateAgentResponse, CreateAgentResponses, CreateAnchorData, CreateAnchorError, CreateAnchorErrors, CreateAnchorResponse, CreateAnchorResponses, CreateBotRequest, CreateBulkDocumentResponse, CreateBulkDocumentResponseData, CreateCanvasDocumentRequest, CreateCanvasDocumentResponse, CreateCanvasHandlerData, CreateCanvasHandlerError, CreateCanvasHandlerErrors, CreateCanvasHandlerResponse, CreateCanvasHandlerResponses, CreateChannelData, CreateChannelError, CreateChannelErrors, CreateChannelLabelData, CreateChannelLabelError, CreateChannelLabelErrors, CreateChannelLabelRequest, CreateChannelLabelResponse, CreateChannelLabelResponses, CreateChannelRequest, CreateChannelResponse, CreateChannelResponse2, CreateChannelResponses, CreateChannelScopedBotData, CreateChannelScopedBotError, CreateChannelScopedBotErrors, CreateChannelScopedBotRequest, CreateChannelScopedBotResponse, CreateChannelScopedBotResponse2, CreateChannelScopedBotResponses, CreateCollabSurfaceTokenData, CreateCollabSurfaceTokenError, CreateCollabSurfaceTokenErrors, CreateCollabSurfaceTokenResponse, CreateCollabSurfaceTokenResponses, CreateCrmCompanyData, CreateCrmCompanyError, CreateCrmCompanyErrors, CreateCrmCompanyRequest, CreateCrmCompanyResponse, CreateCrmCompanyResponses, CreateCrmContactData, CreateCrmContactError, CreateCrmContactErrors, CreateCrmContactRequest, CreateCrmContactResponse, CreateCrmContactResponses, CreateCrmPipelineData, CreateCrmPipelineResponse, CreateCrmPipelineResponses, CreateCrmTeamContactData, CreateCrmTeamContactError, CreateCrmTeamContactErrors, CreateCrmTeamContactRequest, CreateCrmTeamContactResponse, CreateCrmTeamContactResponses, CreateDatabaseData, CreateDatabaseError, CreateDatabaseErrors, CreateDatabaseRequest, CreateDatabaseResponse, CreateDatabaseResponses, CreateDatabaseWebhookData, CreateDatabaseWebhookError, CreateDatabaseWebhookErrors, CreateDatabaseWebhookRequest, CreateDatabaseWebhookResponse, CreateDatabaseWebhookResponses, CreatedDatabaseWebhookResponse, CreateDocumentData, CreateDocumentError, CreateDocumentErrors, CreateDocumentRequest, CreateDocumentResponse, CreateDocumentResponseData, CreateDocumentResponses, CreatedPairing, CreatedUserApiKey, CreateEntityMentionData, CreateEntityMentionError, CreateEntityMentionErrors, CreateEntityMentionRequest, CreateEntityMentionResponse, CreateEntityMentionResponse2, CreateEntityMentionResponses, CreateForm, CreateFormData, CreateFormError, CreateFormErrors, CreateFormResponse, CreateFormResponses, CreateHarnessPairingData, CreateHarnessPairingError, CreateHarnessPairingErrors, CreateHarnessPairingResponse, CreateHarnessPairingResponses, CreateImport, CreateInitiativeData, CreateInitiativeError, CreateInitiativeErrors, CreateInitiativeRequest, CreateInitiativeResponse, CreateInitiativeResponses, CreateInstructionsDocumentResponse, CreateInstructionsHandlerData, CreateInstructionsHandlerError, CreateInstructionsHandlerErrors, CreateInstructionsHandlerResponse, CreateInstructionsHandlerResponses, CreateMarkdownDocumentRequest, CreateMarkdownDocumentResponse, CreateMarkdownHandlerData, CreateMarkdownHandlerError, CreateMarkdownHandlerErrors, CreateMarkdownHandlerResponse, CreateMarkdownHandlerResponses, CreateMeetingRequest, CreatePairingRequest, CreatePipeline, CreateProjectHandlerData, CreateProjectHandlerError, CreateProjectHandlerErrors, CreateProjectHandlerResponse, CreateProjectHandlerResponses, CreateProjectRequest, CreateProjectResponse, CreateSkillHandlerData, CreateSkillHandlerError, CreateSkillHandlerErrors, CreateSkillHandlerResponse, CreateSkillHandlerResponses, CreateSkillRequest, CreateSkillResponse, CreateSlackImportData, CreateSlackImportErrors, CreateSlackImportResponse, CreateSlackImportResponses, CreateSnippetHandlerData, CreateSnippetHandlerError, CreateSnippetHandlerErrors, CreateSnippetHandlerResponse, CreateSnippetHandlerResponses, CreateSnippetRequest, CreateSnippetResponse, CreateTaskHandlerData, CreateTaskHandlerError, CreateTaskHandlerErrors, CreateTaskHandlerResponse, CreateTaskHandlerResponses, CreateTaskRequest, CreateTaskResponse, CreateToken, CreateUnthreadedAnchorRequest, CreateUnthreadedAnchorResponse, CreateUnthreadedPdfAnchorRequest, CreateUserApiKeyData, CreateUserApiKeyError, CreateUserApiKeyErrors, CreateUserApiKeyRequest, CreateUserApiKeyResponse, CreateUserApiKeyResponses, CreateViewHandlerData, CreateViewHandlerError, CreateViewHandlerErrors, CreateViewHandlerResponse, CreateViewHandlerResponses, CreateViewRequest, CreateWebhookData, CreateWebhookError, CreateWebhookErrors, CreateWebhookRequest, CreateWebhookResponse, CreateWebhookResponse2, CreateWebhookResponses, CrmAssociation, CrmBlockedDomainResponse, CrmCompanyFilters, CrmCompanyResponse, CrmContactResponse, CrmDomainResponse, CrmPermissionRole, CrmStageInput, CrmStageResponse, CrmStagesResponse, CrmTeamSettingsResponse, CustomSpeakerAssignment, Database, DatabaseDetail, DatabaseId, DatabaseOp, DatabaseQueryRequest, DatabaseView, DatabaseWebhookDeliveryResponse, DatabaseWebhookPayloadProblem, DatabaseWebhookResponse, DataType, DateOperator, DateRange, DateRangeOperator, DeclineCallData, DeclineCallError, DeclineCallErrors, DeclineCallResponse, DeclineCallResponses, DeclineRingData, DeclineRingError, DeclineRingErrors, DeclineRingResponse, DeclineRingResponses, DeleteAnchorData, DeleteAnchorError, DeleteAnchorErrors, DeleteAnchorResponse, DeleteAnchorResponses, DeleteCallRecordData, DeleteCallRecordError, DeleteCallRecordErrors, DeleteCallRecordResponse, DeleteCallRecordResponses, DeleteChannelData, DeleteChannelError, DeleteChannelErrors, DeleteChannelLabelData, DeleteChannelLabelError, DeleteChannelLabelErrors, DeleteChannelLabelResponse, DeleteChannelLabelResponses, DeleteChannelResponse, DeleteChannelResponses, DeleteCollabSurfaceData, DeleteCollabSurfaceError, DeleteCollabSurfaceErrors, DeleteCollabSurfaceResponse, DeleteCollabSurfaceResponses, DeleteDatabaseWebhookData, DeleteDatabaseWebhookError, DeleteDatabaseWebhookErrors, DeleteDatabaseWebhookResponse, DeleteDatabaseWebhookResponses, DeleteDocumentData, DeleteDocumentError, DeleteDocumentErrors, DeleteDocumentResponse, DeleteDocumentResponses, DeleteEntityMentionData, DeleteEntityMentionError, DeleteEntityMentionErrors, DeleteEntityMentionResponse, DeleteEntityMentionResponse2, DeleteEntityMentionResponses, DeleteHarnessData, DeleteHarnessError, DeleteHarnessErrors, DeleteHarnessResponse, DeleteHarnessResponses, DeleteHistoryHandlerData, DeleteHistoryHandlerError, DeleteHistoryHandlerErrors, DeleteHistoryHandlerResponse, DeleteHistoryHandlerResponses, DeleteInitiativeData, DeleteInitiativeError, DeleteInitiativeErrors, DeleteInitiativeResponse, DeleteInitiativeResponses, DeleteProjectHandlerData, DeleteProjectHandlerError, DeleteProjectHandlerErrors, DeleteProjectHandlerResponse, DeleteProjectHandlerResponses, DeleteSelfHarnessData, DeleteSelfHarnessError, DeleteSelfHarnessErrors, DeleteSelfHarnessResponse, DeleteSelfHarnessResponses, DeleteUnthreadedAnchorRequest, DeleteUnthreadedAnchorResponse, DeleteUnthreadedPdfAnchorRequest, DeleteUserApiKeyData, DeleteUserApiKeyError, DeleteUserApiKeyErrors, DeleteUserApiKeyResponse, DeleteUserApiKeyResponses, DeleteUserDocumentViewLocationData, DeleteUserDocumentViewLocationError, DeleteUserDocumentViewLocationErrors, DeleteUserDocumentViewLocationResponse, DeleteUserDocumentViewLocationResponses, DeleteViewHandlerData, DeleteViewHandlerError, DeleteViewHandlerErrors, DeleteViewHandlerResponses, DeleteWebhookData, DeleteWebhookError, DeleteWebhookErrors, DeleteWebhookResponse, DeleteWebhookResponses, DeliverDatabaseWebhookData, DeliverDatabaseWebhookError, DeliverDatabaseWebhookErrors, DeliverDatabaseWebhookResponse, DeliverDatabaseWebhookResponses, DirectAccess, DocumentAiEdited, DocumentAiEditFailed, DocumentAiEditFailedCode, DocumentAiEditRefused, DocumentAiEditRefusedCode, DocumentAiEditRequest, DocumentBasic, DocumentContent, DocumentContentLocation, DocumentContentState, DocumentContentUploadedMetadata, DocumentCopiedMetadata, DocumentCreatedMetadata, DocumentDeletedMetadata, DocumentFilters, DocumentId, DocumentInteractionMetadata, DocumentMetadata, DocumentMetadataWithContent, DocumentPermissionsToken, DocumentPermissionsTokenRequest, DocumentPermissionsTokenResponse, DocumentPreview, DocumentPreviewData, DocumentPreviewDataSubType, DocumentPurgedMetadata, DocumentResponse, DocumentResponseMetadata, DocumentResponseMetadataWithContent, DocumentStorageServiceApiVersion, DocumentSubType, DocumentSyncContentUpdatedMetadata, DocumentSyncEditor, DocumentTeamShareResponse, DocumentTextContent, DocumentTopicEvent, DocumentUpdatedMetadata, DuplicateDatabaseData, DuplicateDatabaseError, DuplicateDatabaseErrors, DuplicateDatabaseRequest, DuplicateDatabaseResponse, DuplicateDatabaseResponses, EditAnchorData, EditAnchorError, EditAnchorErrors, EditAnchorRequest, EditAnchorResponse, EditAnchorResponse2, EditAnchorResponses, EditCallRecordData, EditCallRecordError, EditCallRecordErrors, EditCallRecordRequest, EditCallRecordResponse, EditCallRecordResponses, EditCallTranscriptData, EditCallTranscriptError, EditCallTranscriptErrors, EditCallTranscriptRequest, EditCallTranscriptResponse, EditCallTranscriptResponses, EditDocumentData, EditDocumentError, EditDocumentErrors, EditDocumentResponse, EditDocumentResponse2, EditDocumentResponses, EditDocumentServiceArgs, EditDocumentWithAiData, EditDocumentWithAiError, EditDocumentWithAiErrors, EditDocumentWithAiResponse, EditDocumentWithAiResponses, EditMyFormResponseData, EditMyFormResponseError, EditMyFormResponseErrors, EditMyFormResponseResponse, EditMyFormResponseResponses, EditPdfAnchorRequest, EditPdfPlaceableCommentAnchorRequest, EditProjectV2Data, EditProjectV2Error, EditProjectV2Errors, EditProjectV2Response, EditProjectV2Responses, EditThreadV2Data, EditThreadV2Error, EditThreadV2Errors, EditThreadV2Response, EditThreadV2Responses, EmailFilters, EmailFollowup, EmailFollowupCommand, EmailFollowupResponse, EmailReminderCondition, EmailReminderPage, EmailReminderSummary, EmptyResponse, EnsureCollabSurfaceData, EnsureCollabSurfaceError, EnsureCollabSurfaceErrors, EnsureCollabSurfaceRequest, EnsureCollabSurfaceResponse, EnsureCollabSurfaceResponses, EnsureStarterHandlerData, EnsureStarterHandlerErrors, EnsureStarterHandlerResponse, EnsureStarterHandlerResponses, EntityFilters, EntityKind, EntityMessageCreateData, EntityMessageCreateResponse, EntityMessageCreateResponses, EntityMessageDeleteMessageData, EntityMessageDeleteMessageResponse, EntityMessageDeleteMessageResponses, EntityMessageDeleteThreadData, EntityMessageDeleteThreadResponse, EntityMessageDeleteThreadResponses, EntityMessageEditData, EntityMessageEditResponse, EntityMessageEditResponses, EntityMessageGetMessageData, EntityMessageGetMessageResponse, EntityMessageGetMessageResponses, EntityMessageGetThreadData, EntityMessageGetThreadResponse, EntityMessageGetThreadResponses, EntityMessageLegacyData, EntityMessageLegacyResponse, EntityMessageLegacyResponses, EntityMessagePatchThreadData, EntityMessagePatchThreadResponse, EntityMessagePatchThreadResponses, EntityMessageReactData, EntityMessageReactResponse, EntityMessageReactResponses, EntityMessageTypingData, EntityMessageTypingResponse, EntityMessageTypingResponses, EntityPermission, EntityPermissionResponse, EntityRef, EntityReference, EntityType, ErrorResponse, EventIcsData, EventIcsErrors, EventIcsResponse, EventIcsResponses, EventReminderOverride, EventReminders, EventStatus, EventTime, EventTransparency, EventType, EventVisibility, ExcludedDefaultView, ExcludeDefaultViewHandlerData, ExcludeDefaultViewHandlerError, ExcludeDefaultViewHandlerErrors, ExcludeDefaultViewHandlerResponses, ExcludeDefaultViewRequest, ExportDocumentData, ExportDocumentError, ExportDocumentErrors, ExportDocumentResponse, ExportDocumentResponse2, ExportDocumentResponses, ExternalChatAdd, ExternalChatAddData, ExternalChatAdded, ExternalChatAddResponse, ExternalChatAddResponses, ExternalChatAttachment, ExternalChatAttachmentState, ExternalChatBackfill, ExternalChatBackfillState, ExternalChatCall, ExternalChatCallOutcome, ExternalChatCapabilities, ExternalChatCommunity, ExternalChatContactCard, ExternalChatContacts, ExternalChatData, ExternalChatDeliveryData, ExternalChatDeliveryResponse, ExternalChatDeliveryResponses, ExternalChatDeliveryState, ExternalChatDetail, ExternalChatEvent, ExternalChatKind, ExternalChatLocation, ExternalChatMediaKind, ExternalChatMediaPresentation, ExternalChatMembers, ExternalChatMention, ExternalChatMessage, ExternalChatMessageAttachments, ExternalChatMessageAttachmentsData, ExternalChatMessageAttachmentsResponse, ExternalChatMessageAttachmentsResponses, ExternalChatMessageData, ExternalChatMessageKind, ExternalChatMessageResponse, ExternalChatMessageResponses, ExternalChatMessages, ExternalChatMessagesData, ExternalChatMessagesResponse, ExternalChatMessagesResponses, ExternalChatMutation, ExternalChatParticipant, ExternalChatPermissionsData, ExternalChatPermissionsResponse, ExternalChatPermissionsResponses, ExternalChatPersonRef, ExternalChatPoll, ExternalChatPollOption, ExternalChatProvider, ExternalChatReaction, ExternalChatReadData, ExternalChatReadResponse, ExternalChatReadResponses, ExternalChatReference, ExternalChatRemoveData, ExternalChatRemoveResponse, ExternalChatRemoveResponses, ExternalChatReplyBlock, ExternalChatReplyContent, ExternalChatResponse, ExternalChatResponses, ExternalChatRichContent, ExternalChatsData, ExternalChatSendData, ExternalChatSender, ExternalChatSendErrors, ExternalChatSendProgress, ExternalChatSendReply, ExternalChatSendResponse, ExternalChatSendResponses, ExternalChatSendsData, ExternalChatSendsResponse, ExternalChatSendsResponses, ExternalChatsResponse, ExternalChatsResponses, ExternalChatSummary, ExternalChatSystemAction, ExternalChatSystemLine, ExternalChatUpdatePermissionsData, ExternalChatUpdatePermissionsResponse, ExternalChatUpdatePermissionsResponses, ExternalChatUploadData, ExternalChatUploadedAttachment, ExternalChatUploadRequest, ExternalChatUploadResponse, ExternalChatUploadResponses, Favorite, FavoriteEntityRef, FavoritesList, FileChangeKindDto, FileSystemNodeWithIds, FileType, FileTypeUpdate, FilterCondition, FilterGroup, FilterNode, FilterTest, FinalizeSlackImportData, FinalizeSlackImportErrors, FinalizeSlackImportResponse, FinalizeSlackImportResponses, FolderItem, FollowupState, ForeignEntity, ForeignEntityFilters, Form, FormAccess, FormBranding, FormCollaboration, FormDetail, FormErrorCode, FormErrorResponse, FormLayout, FormPublicationProblem, FormQuestionDetail, FormResponse, FormSection, FormSectionDetail, FormSource, FormStatus, FormTally, Formula, GenericErrorResponse, GenericResponse, GenericSuccessResponse, GetActiveCallsData, GetActiveCallsError, GetActiveCallsErrors, GetActiveCallsResponse, GetActiveCallsResponses, GetActivityData, GetActivityError, GetActivityErrors, GetActivityResponse, GetActivityResponses, GetAttachmentReferencesData, GetAttachmentReferencesError, GetAttachmentReferencesErrors, GetAttachmentReferencesResponse, GetAttachmentReferencesResponse2, GetAttachmentReferencesResponses, GetBatchCallRecordPreviewData, GetBatchCallRecordPreviewError, GetBatchCallRecordPreviewErrors, GetBatchCallRecordPreviewRequest, GetBatchCallRecordPreviewResponse, GetBatchCallRecordPreviewResponse2, GetBatchCallRecordPreviewResponses, GetBatchChannelPreviewData, GetBatchChannelPreviewError, GetBatchChannelPreviewErrors, GetBatchChannelPreviewRequest, GetBatchChannelPreviewResponse, GetBatchChannelPreviewResponse2, GetBatchChannelPreviewResponses, GetBatchPreviewHandlerData, GetBatchPreviewHandlerError, GetBatchPreviewHandlerErrors, GetBatchPreviewHandlerResponse, GetBatchPreviewHandlerResponses, GetBatchPreviewRequest, GetBatchPreviewResponse, GetBatchProjectPreviewData, GetBatchProjectPreviewError, GetBatchProjectPreviewErrors, GetBatchProjectPreviewRequest, GetBatchProjectPreviewResponse, GetBatchProjectPreviewResponse2, GetBatchProjectPreviewResponses, GetBotOwnerProfilesData, GetBotOwnerProfilesError, GetBotOwnerProfilesErrors, GetBotOwnerProfilesResponse, GetBotOwnerProfilesResponses, GetCallRecordData, GetCallRecordError, GetCallRecordErrors, GetCallRecordResponse, GetCallRecordResponses, GetChannelAttachmentsData, GetChannelAttachmentsError, GetChannelAttachmentsErrors, GetChannelAttachmentsResponse, GetChannelAttachmentsResponses, GetChannelData, GetChannelError, GetChannelErrors, GetChannelJoinLinkData, GetChannelJoinLinkError, GetChannelJoinLinkErrors, GetChannelJoinLinkResponse, GetChannelJoinLinkResponses, GetChannelParticipantsData, GetChannelParticipantsError, GetChannelParticipantsErrors, GetChannelParticipantsResponse, GetChannelParticipantsResponses, GetChannelResponse, GetChannelResponses, GetChannelsData, GetChannelsError, GetChannelsErrors, GetChannelsResponse, GetChannelsResponses, GetCollabSurfaceData, GetCollabSurfaceError, GetCollabSurfaceErrors, GetCollabSurfaceResponse, GetCollabSurfaceResponses, GetCompanyData, GetCompanyError, GetCompanyErrors, GetCompanyResponse, GetCompanyResponses, GetContactByEmailData, GetContactByEmailError, GetContactByEmailErrors, GetContactByEmailResponse, GetContactByEmailResponse2, GetContactByEmailResponses, GetContactData, GetContactError, GetContactErrors, GetContactResponse, GetContactResponses, GetCrmPipelineData, GetCrmPipelinePermissionsData, GetCrmPipelinePermissionsResponse, GetCrmPipelinePermissionsResponses, GetCrmPipelineResponse, GetCrmPipelineResponses, GetCrmPipelineRowsData, GetCrmPipelineRowsResponse, GetCrmPipelineRowsResponses, GetCrmPipelineTableData, GetCrmPipelineTableResponse, GetCrmPipelineTableResponses, GetCrmPipelineViewPositionsData, GetCrmPipelineViewPositionsResponse, GetCrmPipelineViewPositionsResponses, GetCrmTeamSettingsData, GetCrmTeamSettingsError, GetCrmTeamSettingsErrors, GetCrmTeamSettingsResponse, GetCrmTeamSettingsResponses, GetDatabaseData, GetDatabaseError, GetDatabaseErrors, GetDatabasePermissionsData, GetDatabasePermissionsError, GetDatabasePermissionsErrors, GetDatabasePermissionsResponse, GetDatabasePermissionsResponses, GetDatabaseQueryData, GetDatabaseQueryError, GetDatabaseQueryErrors, GetDatabaseQueryResponse, GetDatabaseQueryResponses, GetDatabaseResponse, GetDatabaseResponses, GetDatabaseRowHistoryData, GetDatabaseRowHistoryError, GetDatabaseRowHistoryErrors, GetDatabaseRowHistoryResponse, GetDatabaseRowHistoryResponses, GetDatabaseTableChangesData, GetDatabaseTableChangesError, GetDatabaseTableChangesErrors, GetDatabaseTableChangesResponse, GetDatabaseTableChangesResponses, GetDatabaseViewPositionsData, GetDatabaseViewPositionsError, GetDatabaseViewPositionsErrors, GetDatabaseViewPositionsResponse, GetDatabaseViewPositionsResponses, GetDocumentAnchorsData, GetDocumentAnchorsError, GetDocumentAnchorsErrors, GetDocumentAnchorsResponse, GetDocumentAnchorsResponses, GetDocumentBranchNameData, GetDocumentBranchNameError, GetDocumentBranchNameErrors, GetDocumentBranchNameResponse, GetDocumentBranchNameResponses, GetDocumentByTeamSlugData, GetDocumentByTeamSlugError, GetDocumentByTeamSlugErrors, GetDocumentByTeamSlugResponse, GetDocumentByTeamSlugResponses, GetDocumentData, GetDocumentError, GetDocumentErrors, GetDocumentGithubPullRequestsData, GetDocumentGithubPullRequestsError, GetDocumentGithubPullRequestsErrors, GetDocumentGithubPullRequestsResponse, GetDocumentGithubPullRequestsResponses, GetDocumentKeyResponse, GetDocumentKeyResponseData, GetDocumentListHandlerData, GetDocumentListHandlerError, GetDocumentListHandlerErrors, GetDocumentListHandlerResponse, GetDocumentListHandlerResponses, GetDocumentListResult, GetDocumentLocationV3Data, GetDocumentLocationV3Error, GetDocumentLocationV3Errors, GetDocumentLocationV3Response, GetDocumentLocationV3Responses, GetDocumentPermissionsResponseDataV2, GetDocumentPermissionsTokenData, GetDocumentPermissionsTokenError, GetDocumentPermissionsTokenErrors, GetDocumentPermissionsTokenResponse, GetDocumentPermissionsTokenResponses, GetDocumentPermissionsV2Data, GetDocumentPermissionsV2Error, GetDocumentPermissionsV2Errors, GetDocumentPermissionsV2Response, GetDocumentPermissionsV2Responses, GetDocumentProcessingResult, GetDocumentProcessingResultData, GetDocumentProcessingResultError, GetDocumentProcessingResultErrors, GetDocumentProcessingResultResponse, GetDocumentProcessingResultResponse2, GetDocumentProcessingResultResponses, GetDocumentResponse, GetDocumentResponse2, GetDocumentResponseData, GetDocumentResponses, GetDocumentSearchResponse, GetDocumentShortIdData, GetDocumentShortIdError, GetDocumentShortIdErrors, GetDocumentShortIdResponse, GetDocumentShortIdResponses, GetDocumentsResponse, GetDocumentTeamShareData, GetDocumentTeamShareError, GetDocumentTeamShareErrors, GetDocumentTeamShareResponse, GetDocumentTeamShareResponses, GetDocumentTextContentData, GetDocumentTextContentErrors, GetDocumentTextContentResponse, GetDocumentTextContentResponses, GetDocumentUserAccessLevelResponse, GetDocumentVersionData, GetDocumentVersionError, GetDocumentVersionErrors, GetDocumentVersionResponse, GetDocumentVersionResponses, GetDocumentViewsHandlerData, GetDocumentViewsHandlerError, GetDocumentViewsHandlerErrors, GetDocumentViewsHandlerResponse, GetDocumentViewsHandlerResponses, GetEmailFollowupData, GetEmailFollowupError, GetEmailFollowupErrors, GetEmailFollowupResponse, GetEmailFollowupResponses, GetEntityPermissionData, GetEntityPermissionErrors, GetEntityPermissionResponse, GetEntityPermissionResponses, GetForeignEntityBySourceData, GetForeignEntityBySourceError, GetForeignEntityBySourceErrors, GetForeignEntityBySourceResponse, GetForeignEntityBySourceResponses, GetForeignEntityData, GetForeignEntityError, GetForeignEntityErrors, GetForeignEntityResponse, GetForeignEntityResponses, GetFormData, GetFormError, GetFormErrors, GetFormPermissionsData, GetFormPermissionsError, GetFormPermissionsErrors, GetFormPermissionsResponse, GetFormPermissionsResponses, GetFormResponse, GetFormResponses, GetFormResponseSummaryData, GetFormResponseSummaryError, GetFormResponseSummaryErrors, GetFormResponseSummaryResponse, GetFormResponseSummaryResponses, GetFormTallyData, GetFormTallyError, GetFormTallyErrors, GetFormTallyResponse, GetFormTallyResponses, GetGithubPullRequestChangesData, GetGithubPullRequestChangesError, GetGithubPullRequestChangesErrors, GetGithubPullRequestChangesPatchData, GetGithubPullRequestChangesPatchError, GetGithubPullRequestChangesPatchErrors, GetGithubPullRequestChangesPatchResponse, GetGithubPullRequestChangesPatchResponses, GetGithubPullRequestChangesResponse, GetGithubPullRequestChangesResponses, GetGithubPullRequestData, GetGithubPullRequestError, GetGithubPullRequestErrors, GetGithubPullRequestFacetsData, GetGithubPullRequestFacetsError, GetGithubPullRequestFacetsErrors, GetGithubPullRequestFacetsResponse, GetGithubPullRequestFacetsResponses, GetGithubPullRequestResponse, GetGithubPullRequestResponses, GetGithubPullRequestTasksData, GetGithubPullRequestTasksError, GetGithubPullRequestTasksErrors, GetGithubPullRequestTasksResponse, GetGithubPullRequestTasksResponses, GetHarnessPairingData, GetHarnessPairingError, GetHarnessPairingErrors, GetHarnessPairingResponse, GetHarnessPairingResponses, GetHistoryHandlerData, GetHistoryHandlerError, GetHistoryHandlerErrors, GetHistoryHandlerResponse, GetHistoryHandlerResponses, GetInitiativeData, GetInitiativeError, GetInitiativeErrors, GetInitiativeResponse, GetInitiativeResponses, GetInstructionsDocumentResponse, GetInstructionsHandlerData, GetInstructionsHandlerError, GetInstructionsHandlerErrors, GetInstructionsHandlerResponse, GetInstructionsHandlerResponses, GetItemsSoupData, GetItemsSoupError, GetItemsSoupErrors, GetItemsSoupResponse, GetItemsSoupResponses, GetLocationHandlerData, GetLocationHandlerError, GetLocationHandlerErrors, GetLocationHandlerResponse, GetLocationHandlerResponses, GetMyFormResponseData, GetMyFormResponseError, GetMyFormResponseErrors, GetMyFormResponseResponse, GetMyFormResponseResponses, GetOrCreateAction, GetOrCreateCallData, GetOrCreateCallError, GetOrCreateCallErrors, GetOrCreateCallResponse, GetOrCreateCallResponses, GetOrCreateChannelResponse, GetOrCreateDmData, GetOrCreateDmError, GetOrCreateDmErrors, GetOrCreateDmRequest, GetOrCreateDmResponse, GetOrCreateDmResponses, GetOrCreatePrivateData, GetOrCreatePrivateError, GetOrCreatePrivateErrors, GetOrCreatePrivateRequest, GetOrCreatePrivateResponse, GetOrCreatePrivateResponses, GetPendingProjectsHandlerData, GetPendingProjectsHandlerError, GetPendingProjectsHandlerErrors, GetPendingProjectsHandlerResponse, GetPendingProjectsHandlerResponses, GetPinsHandlerData, GetPinsHandlerError, GetPinsHandlerErrors, GetPinsHandlerResponse, GetPinsHandlerResponses, GetPinsResponse, GetProjectContentHandlerData, GetProjectContentHandlerError, GetProjectContentHandlerErrors, GetProjectContentHandlerResponse, GetProjectContentHandlerResponses, GetProjectContentResponse, GetProjectHandlerData, GetProjectHandlerError, GetProjectHandlerErrors, GetProjectHandlerResponse, GetProjectHandlerResponses, GetProjectPermissionsV2Data, GetProjectPermissionsV2Error, GetProjectPermissionsV2Errors, GetProjectPermissionsV2Response, GetProjectPermissionsV2Responses, GetProjectResponse, GetProjectResponseData, GetProjectsHandlerData, GetProjectsHandlerError, GetProjectsHandlerErrors, GetProjectsHandlerResponse, GetProjectsHandlerResponses, GetProjectsResponse, GetProjectUserAccessLevelData, GetProjectUserAccessLevelError, GetProjectUserAccessLevelErrors, GetProjectUserAccessLevelResponse, GetProjectUserAccessLevelResponses, GetRingStatusData, GetRingStatusError, GetRingStatusErrors, GetRingStatusResponse, GetRingStatusResponses, GetSelfBotData, GetSelfBotError, GetSelfBotErrors, GetSelfBotResponse, GetSelfBotResponses, GetSelfHarnessData, GetSelfHarnessError, GetSelfHarnessErrors, GetSelfHarnessResponse, GetSelfHarnessResponses, GetSkillDescriptionData, GetSkillDescriptionError, GetSkillDescriptionErrors, GetSkillDescriptionResponse, GetSkillDescriptionResponses, GetSlackImportData, GetSlackImportErrors, GetSlackImportResponse, GetSlackImportResponses, GetSystemSkillsHandlerData, GetSystemSkillsHandlerError, GetSystemSkillsHandlerErrors, GetSystemSkillsHandlerResponse, GetSystemSkillsHandlerResponses, GetUserDocumentsHandlerData, GetUserDocumentsHandlerError, GetUserDocumentsHandlerErrors, GetUserDocumentsHandlerResponse, GetUserDocumentsHandlerResponses, GetUserDocumentViewLocationData, GetUserDocumentViewLocationError, GetUserDocumentViewLocationErrors, GetUserDocumentViewLocationResponse, GetUserDocumentViewLocationResponses, GetUserHistoryResponse, GetViewsHandlerData, GetViewsHandlerError, GetViewsHandlerErrors, GetViewsHandlerResponse, GetViewsHandlerResponses, GetWebhookData, GetWebhookError, GetWebhookErrors, GetWebhookResponse, GetWebhookResponses, GithubLabelFacet, GithubPullRequest, GithubPullRequestChangesPatchResponse, GithubPullRequestChangesResponse, GithubPullRequestCheckRun, GithubPullRequestComment, GithubPullRequestFacets, GithubPullRequestLabel, GithubPullRequestReview, GithubPullRequestReviewDecision, GithubPullRequestReviewState, GithubPullRequestsResponse, GithubPullRequestTasks, GithubPullRequestTasksRequest, GithubPullRequestTasksResponse, GithubPullRequestUser, GithubRepositoryFacet, GithubUserFacet, GitRefDto, GroupedInitialParams, GroupedPageParams, GroupedSoupGroupPage, GroupedSoupInitialPage, GroupedSoupPage, GroupedSoupSort, GuestCallChatPostData, GuestCallChatPostErrors, GuestCallChatPostResponse, GuestCallChatPostResponses, GuestCallChatReadData, GuestCallChatReadErrors, GuestCallChatReadResponse, GuestCallChatReadResponses, GuestChatMessage, GuestChatPage, GuestChatPost, GuestId, GuestJoinRequest, GuestPolicy, HandlerData, HandlerError, HandlerErrors, HandlerResponse, HandlerResponses, Harness, HarnessAgent, HarnessId, HarnessOwner, HarnessSession, HashMap, HealthHandlerData, HealthHandlerResponse, HealthHandlerResponses, HighlightType, ImportCounters, ImportDatabaseTableData, ImportDatabaseTableError, ImportDatabaseTableErrors, ImportDatabaseTableResponse, ImportDatabaseTableResponses, ImportedAuthor, ImportError, ImportLimits, ImportPage, ImportProgress, ImportTable, ImportWarning, InferColumnTypeOutcome, InferColumnTypeRequest, InferDatabaseColumnTypeData, InferDatabaseColumnTypeError, InferDatabaseColumnTypeErrors, InferDatabaseColumnTypeResponse, InferDatabaseColumnTypeResponses, InFlightTurnSummary, IngestTranscriptData, IngestTranscriptError, IngestTranscriptErrors, IngestTranscriptResponses, InitializeUserDocumentsData, InitializeUserDocumentsError, InitializeUserDocumentsErrors, InitializeUserDocumentsResponse, InitializeUserDocumentsResponses, InitialPropertyValue, InitiativeDetail, InitiativeFilters, InitiativeId, InitiativeList, InitiativeSummary, InputReceivedMetadata, InstallSyncData, InstallSyncErrors, InteractionReason, InvalidDatabaseWebhookPayloadResponse, InviteMeetingRequest, InviteMeetingUsersRequest, Item, ItemWithUserAccessLevel, JobId, JobProcessingResultHandlerData, JobProcessingResultHandlerError, JobProcessingResultHandlerErrors, JobProcessingResultHandlerResponse, JobProcessingResultHandlerResponses, JobStatus, JoinChannelByCodeData, JoinChannelByCodeError, JoinChannelByCodeErrors, JoinChannelByCodeResponses, JoinChannelData, JoinChannelError, JoinChannelErrors, JoinChannelResponses, KeySegment, Lane, LaneKey, LatestMessage, LayoutProblem, LeaveCallResponse, LeaveChannelData, LeaveChannelError, LeaveChannelErrors, LeaveChannelResponses, LeaveOrEndCallData, LeaveOrEndCallError, LeaveOrEndCallErrors, LeaveOrEndCallResponse, LeaveOrEndCallResponses, LinkShare, ListAccessibleFormsData, ListAccessibleFormsError, ListAccessibleFormsErrors, ListAccessibleFormsResponse, ListAccessibleFormsResponses, ListAgentsData, ListAgentsError, ListAgentsErrors, ListAgentsResponse, ListAgentsResponses, ListBotChannelsData, ListBotChannelsError, ListBotChannelsErrors, ListBotChannelsResponse, ListBotChannelsResponses, ListChannelLabelsData, ListChannelLabelsError, ListChannelLabelsErrors, ListChannelLabelsResponse, ListChannelLabelsResponses, ListCompanyContactsData, ListCompanyContactsError, ListCompanyContactsErrors, ListCompanyContactsResponse, ListCompanyContactsResponses, ListCrmBlockedDomainsData, ListCrmBlockedDomainsError, ListCrmBlockedDomainsErrors, ListCrmBlockedDomainsResponse, ListCrmBlockedDomainsResponses, ListCrmPipelinesData, ListCrmPipelinesResponse, ListCrmPipelinesResponses, ListDatabaseColumnCastsData, ListDatabaseColumnCastsError, ListDatabaseColumnCastsErrors, ListDatabaseColumnCastsResponse, ListDatabaseColumnCastsResponses, ListDatabasesData, ListDatabasesError, ListDatabasesErrors, ListDatabasesResponse, ListDatabasesResponses, ListDatabaseWebhooksData, ListDatabaseWebhooksError, ListDatabaseWebhooksErrors, ListDatabaseWebhooksResponse, ListDatabaseWebhooksResponse2, ListDatabaseWebhooksResponses, ListedDatabase, ListedForm, ListEmailRemindersData, ListEmailRemindersError, ListEmailRemindersErrors, ListEmailRemindersResponse, ListEmailRemindersResponses, ListFavoritesData, ListFavoritesError, ListFavoritesErrors, ListFavoritesResponse, ListFavoritesResponses, ListFormsData, ListFormsError, ListFormsErrors, ListFormsResponse, ListFormsResponses, ListHarnessAgentsData, ListHarnessAgentsError, ListHarnessAgentsErrors, ListHarnessAgentsResponse, ListHarnessAgentsResponses, ListHarnessesData, ListHarnessesError, ListHarnessesErrors, ListHarnessesResponse, ListHarnessesResponses, ListHarnessSessionsData, ListHarnessSessionsError, ListHarnessSessionsErrors, ListHarnessSessionsResponse, ListHarnessSessionsResponses, ListInitiativesData, ListInitiativesError, ListInitiativesErrors, ListInitiativesResponse, ListInitiativesResponses, ListJoinRequestsData, ListJoinRequestsError, ListJoinRequestsErrors, ListJoinRequestsResponse, ListJoinRequestsResponses, ListOccurrencesData, ListOccurrencesErrors, ListOccurrencesResponse, ListOccurrencesResponses, ListSlackImportsData, ListSlackImportsResponse, ListSlackImportsResponses, ListTeamCalendarData, ListTeamCalendarResponse, ListTeamCalendarResponses, ListTeamOutOfOfficeData, ListTeamOutOfOfficeErrors, ListTeamOutOfOfficeResponse, ListTeamOutOfOfficeResponses, ListUserApiKeysData, ListUserApiKeysError, ListUserApiKeysErrors, ListUserApiKeysResponse, ListUserApiKeysResponses, ListWebhooksData, ListWebhooksError, ListWebhooksErrors, ListWebhooksResponse, ListWebhooksResponse2, ListWebhooksResponses, LocationResponseData, LocationResponseV3, MacroUserIdStr, MarkRead, Meeting, MeetingCancelData, MeetingCancelError, MeetingCancelErrors, MeetingCancelPreparationData, MeetingCancelPreparationError, MeetingCancelPreparationErrors, MeetingCancelPreparationResponse, MeetingCancelPreparationResponses, MeetingCancelResponse, MeetingCancelResponses, MeetingCreateData, MeetingCreateError, MeetingCreateErrors, MeetingCreateResponse, MeetingCreateResponses, MeetingGuestJoinData, MeetingGuestJoinError, MeetingGuestJoinErrors, MeetingGuestJoinResponse, MeetingGuestJoinResponses, MeetingGuestParticipantsData, MeetingGuestParticipantsError, MeetingGuestParticipantsErrors, MeetingGuestParticipantsResponse, MeetingGuestParticipantsResponses, MeetingInviteData, MeetingInviteError, MeetingInviteErrors, MeetingInvitePermissions, MeetingInvitePermissionsData, MeetingInvitePermissionsError, MeetingInvitePermissionsErrors, MeetingInvitePermissionsResponse, MeetingInvitePermissionsResponses, MeetingInviteResponse, MeetingInviteResponses, MeetingInviteUsersData, MeetingInviteUsersError, MeetingInviteUsersErrors, MeetingInviteUsersResponse, MeetingInviteUsersResponses, MeetingJoinData, MeetingJoinError, MeetingJoinErrors, MeetingJoinResponse, MeetingJoinResponses, MeetingLeaveData, MeetingLeaveError, MeetingLeaveErrors, MeetingLeaveResponse, MeetingLeaveResponses, MeetingListActiveData, MeetingListActiveError, MeetingListActiveErrors, MeetingListActiveResponse, MeetingListActiveResponses, MeetingListData, MeetingListError, MeetingListErrors, MeetingListResponse, MeetingListResponses, MeetingLookupData, MeetingLookupError, MeetingLookupErrors, MeetingLookupResponse, MeetingLookupResponses, MeetingParticipant, MeetingParticipants, MeetingParticipantsData, MeetingParticipantsError, MeetingParticipantsErrors, MeetingParticipantsResponse, MeetingParticipantsResponses, MeetingPreparation, MeetingPrepareData, MeetingPrepareError, MeetingPrepareErrors, MeetingPrepareResponse, MeetingPrepareResponses, MeetingShareData, MeetingShareError, MeetingShareErrors, MeetingShareResponse, MeetingShareResponses, MeetingsResponse, MeetingToken, MeetingUpdateData, MeetingUpdateError, MeetingUpdateErrors, MeetingUpdateResponse, MeetingUpdateResponses, MentionPreviewsData, MentionPreviewsErrors, MentionPreviewsResponse, MentionPreviewsResponses, Message, MessageAttachment, MessageAttachmentCreatedMetadata, MessageAttachmentRemovedMetadata, MessageChange, MessageCursor, MessageDeletedMetadata, MessageDirection, MessageEvent, MessageEventAttachment, MessageListItem, MessageMentionedMetadata, MessagePage, MessageParent, MessagePatch, MessagePatchedMetadata, MessagePostedMetadata, MessageThread, MessageThreadPreview, MessageTimelineData, MessageTimelineEntriesData, MessageTimelineEntriesResponse, MessageTimelineEntriesResponses, MessageTimelineEntry, MessageTimelinePage, MessageTimelineQuery, MessageTimelineResponse, MessageTimelineResponses, MessageTopicEvent, MyResponse, NewAttachment, NewColumn, NewOption, NewThreadAnchor, NewView, NotificationFilters, NotificationState, NumberOperator, OpBatch, Operator, OpRefusalResponse, OpResult, OptionId, OptionRef, PairingDetails, Params, ParticipantRole, PatchBotRequest, PatchChannelData, PatchChannelError, PatchChannelErrors, PatchChannelRequest, PatchChannelResponse, PatchChannelResponses, PatchMessageNotificationPolicy, PatchProjectRequestV2, PatchThreadRequestV2, PatchViewHandlerData, PatchViewHandlerError, PatchViewHandlerErrors, PatchViewHandlerResponses, PatchWebhookData, PatchWebhookError, PatchWebhookErrors, PatchWebhookRequest, PatchWebhookResponse, PatchWebhookResponses, PdfAnchor, PdfAnchorId, PdfHighlightAnchor, PdfHighlightAnchorRequest, PdfHighlightRect, PdfHighlightRectAnchorRequest, PdfPlaceableCommentAnchor, PendingClaimResponse, PermanentlyDeleteDocumentData, PermanentlyDeleteDocumentError, PermanentlyDeleteDocumentErrors, PermanentlyDeleteDocumentResponse, PermanentlyDeleteDocumentResponses, PermanentlyDeleteProjectData, PermanentlyDeleteProjectError, PermanentlyDeleteProjectErrors, PermanentlyDeleteProjectResponse, PermanentlyDeleteProjectResponses, PinnedItem, PinRequest, Pipeline, PipelineRecordType, PipelineSharing, PostActivityData, PostActivityError, PostActivityErrors, PostActivityRequest, PostActivityResponse, PostActivityResponses, PostChannelBotWebhookData, PostChannelBotWebhookError, PostChannelBotWebhookErrors, PostChannelBotWebhookResponse, PostChannelBotWebhookResponses, PostGroupedSoupAstGroupPageRequest, PostGroupedSoupAstInitialRequest, PostGroupedSoupAstRequest, PostItemsSoupAstData, PostItemsSoupAstError, PostItemsSoupAstErrors, PostItemsSoupAstGroupedData, PostItemsSoupAstGroupedError, PostItemsSoupAstGroupedErrors, PostItemsSoupAstGroupedResponse, PostItemsSoupAstGroupedResponses, PostItemsSoupAstResponse, PostItemsSoupAstResponses, PostItemsSoupData, PostItemsSoupError, PostItemsSoupErrors, PostItemsSoupResponse, PostItemsSoupResponses, PostMessage, PostMessageNotificationPolicy, PostSoupAstRequest, PostSoupRequest, PresaveDocumentHandlerData, PresaveDocumentHandlerError, PresaveDocumentHandlerErrors, PresaveDocumentHandlerResponse, PresaveDocumentHandlerResponses, PreSaveDocumentRequest, PreSaveDocumentResponse, PreSaveDocumentResponseData, PresenceOperator, PresignedUrl, PreviewSmartTagData, PreviewSmartTagError, PreviewSmartTagErrors, PreviewSmartTagResponse, PreviewSmartTagResponses, Project, ProjectDeleteResponseData, ProjectDocumentStatus, ProjectFilters, ProjectPreview, ProjectPreviewData, PropertyBucketing, PropertyDateFilterRange, PropertyDateRange, PropertyDateRanges, PropertyDefinition, PropertyDefinitionWithOptions, PropertyFilter, PropertyInput, PropertyOption, PropertyOptionValue, PropertyOwner, PropertyValue, PutCrmTeamSettingsData, PutCrmTeamSettingsError, PutCrmTeamSettingsErrors, PutCrmTeamSettingsResponse, PutCrmTeamSettingsResponses, PutCrmTeamStagesData, PutCrmTeamStagesError, PutCrmTeamStagesErrors, PutCrmTeamStagesResponse, PutCrmTeamStagesResponses, PutFormLayoutData, PutFormLayoutError, PutFormLayoutErrors, PutFormLayoutResponse, PutFormLayoutResponses, QueryCrmPipelineRowsData, QueryCrmPipelineRowsResponse, QueryCrmPipelineRowsResponses, QueryDatabasesData, QueryDatabasesError, QueryDatabasesErrors, QueryDatabasesResponse, QueryDatabasesResponses, QueryDefinition, QuestionLayout, QuestionOption, QuestionTally, ReactionInput, RecentlyDeletedData, RecentlyDeletedError, RecentlyDeletedErrors, RecentlyDeletedResponse, RecentlyDeletedResponseData, RecentlyDeletedResponses, RegisterSlackImportUploadsData, RegisterSlackImportUploadsErrors, RegisterSlackImportUploadsResponse, RegisterSlackImportUploadsResponses, RegisterUploads, RemoveBotFromChannelByBotData, RemoveBotFromChannelByBotError, RemoveBotFromChannelByBotErrors, RemoveBotFromChannelByBotResponse, RemoveBotFromChannelByBotResponses, RemoveFavoriteByEntityData, RemoveFavoriteByEntityError, RemoveFavoriteByEntityErrors, RemoveFavoriteByEntityResponses, RemoveParticipantsData, RemoveParticipantsError, RemoveParticipantsErrors, RemoveParticipantsRequest, RemoveParticipantsResponses, RemovePinHandlerData, RemovePinHandlerError, RemovePinHandlerErrors, RemovePinHandlerResponse, RemovePinHandlerResponses, RenameChannelLabelData, RenameChannelLabelError, RenameChannelLabelErrors, RenameChannelLabelRequest, RenameChannelLabelResponse, RenameChannelLabelResponses, RenameCrmPipelineData, RenameCrmPipelineResponse, RenameCrmPipelineResponses, RenamePipeline, ReorderFavoritesData, ReorderFavoritesError, ReorderFavoritesErrors, ReorderFavoritesRequest, ReorderFavoritesResponses, ReorderPinRequest, ReorderPinsHandlerData, ReorderPinsHandlerError, ReorderPinsHandlerErrors, ReorderPinsHandlerResponse, ReorderPinsHandlerResponses, ReplaceCrmStagesRequest, RequestAccess, RequestedHarnessScope, RequestedLayout, RequestStatus, RequestToJoinData, RequestToJoinError, RequestToJoinErrors, RequestToJoinResponse, RequestToJoinResponses, ResetCrmTeamStagesData, ResetCrmTeamStagesError, ResetCrmTeamStagesErrors, ResetCrmTeamStagesResponse, ResetCrmTeamStagesResponses, ResolveRequest, ResponseStatus, ResponseSummary, ResultColumn, ResultSet, RevertDeleteDocumentData, RevertDeleteDocumentError, RevertDeleteDocumentErrors, RevertDeleteDocumentResponse, RevertDeleteDocumentResponses, RevertDeleteProjectData, RevertDeleteProjectError, RevertDeleteProjectErrors, RevertDeleteProjectResponse, RevertDeleteProjectResponses, RingStatus, RingStatusResponse, RowChange, RowChangeKind, RowChanges, RowHistoryEntry, RowHistoryResponse, RowId, RowsChange, RowsResult, S3ObjectInfo, SaveBomPart, SaveDatabaseQueryData, SaveDatabaseQueryError, SaveDatabaseQueryErrors, SaveDatabaseQueryResponse, SaveDatabaseQueryResponses, SaveDocumentHandlerData, SaveDocumentHandlerError, SaveDocumentHandlerErrors, SaveDocumentHandlerResponse, SaveDocumentHandlerResponses, SaveDocumentRequest, SaveDocumentResponse, SaveDocumentResponseData, SavedQuery, SaveQueryRequest, SearchContactsData, SearchContactsError, SearchContactsErrors, SearchContactsResponse, SearchContactsResponse2, SearchContactsResponses, SearchState, SectionCount, SessionDeletedMetadata, SessionIdentity, SessionMentionedMetadata, SessionOpenedMetadata, SessionRenamedMetadata, SessionSettledMetadata, SessionSource, SessionStoppedMetadata, SetChannelLabelData, SetChannelLabelError, SetChannelLabelErrors, SetChannelLabelRequest, SetChannelLabelResponse, SetChannelLabelResponses, SetChannelPictureData, SetChannelPictureError, SetChannelPictureErrors, SetChannelPictureRequest, SetChannelPictureResponse, SetChannelPictureResponses, SetCompanyHiddenData, SetCompanyHiddenError, SetCompanyHiddenErrors, SetCompanyHiddenRequest, SetCompanyHiddenResponse, SetCompanyHiddenResponses, SetCompanyNameRequest, SetContactHiddenData, SetContactHiddenError, SetContactHiddenErrors, SetContactHiddenRequest, SetContactHiddenResponse, SetContactHiddenResponses, SetContactNameRequest, SetCrmCompanyNameData, SetCrmCompanyNameError, SetCrmCompanyNameErrors, SetCrmCompanyNameResponse, SetCrmCompanyNameResponses, SetCrmContactNameData, SetCrmContactNameError, SetCrmContactNameErrors, SetCrmContactNameResponse, SetCrmContactNameResponses, SetDirectAccess, SetDocumentTeamShareData, SetDocumentTeamShareError, SetDocumentTeamShareErrors, SetDocumentTeamShareRequest, SetDocumentTeamShareResponse, SetDocumentTeamShareResponses, SetEmailFollowupData, SetEmailFollowupError, SetEmailFollowupErrors, SetEmailFollowupResponse, SetEmailFollowupResponses, SetEmailSyncData, SetEmailSyncError, SetEmailSyncErrors, SetEmailSyncRequest, SetEmailSyncResponse, SetEmailSyncResponses, SetOperator, SetPropertyValue, SetSkillDescriptionData, SetSkillDescriptionError, SetSkillDescriptionErrors, SetSkillDescriptionRequest, SetSkillDescriptionResponse, SetSkillDescriptionResponses, Sha256Digest, ShareCrmPipelineData, ShareCrmPipelineResponse, ShareCrmPipelineResponses, ShareDatabaseAwarenessData, ShareDatabaseAwarenessError, ShareDatabaseAwarenessErrors, ShareDatabaseAwarenessResponse, ShareDatabaseAwarenessResponses, SharedEmailFilter, SharedExternalChatReference, ShareEntity, ShareEntityType, SharePermissionV2, SharePipeline, ShortIdResponse, SimpleMention, SimpleSaveData, SimpleSaveError, SimpleSaveErrors, SimpleSaveResponse, SimpleSaveResponses, SkillDescriptionBody, SkippedCell, SlackCompleteRequest, SlackCreateRequest, SlackRegisterRequest, SlackTimestamp, SlackUserId, SmartTagChannelMatch, SmartTagPreview, SortDirection, SortKey, SoupAgentSessionSoupPropertiesField, SoupApiItem, SoupApiSort, SoupApiSortDirection, SoupAttachment, SoupCalendarEventSoupPropertiesField, SoupCalendarEventTime, SoupCallRecordGuest, SoupCallRecordParticipant, SoupCallRecordSoupPropertiesField, SoupChannel, SoupChannelThread, SoupChatSoupPropertiesField, SoupContact, SoupCountedReaction, SoupCrmCompanySoupPropertiesField, SoupCrmContactSoupPropertiesField, SoupCrmDomain, SoupDatabaseRowSoupPropertiesField, SoupDocumentSoupPropertiesField, SoupDocumentSubType, SoupEmailThreadPreview, SoupEnrichedEmailThreadPreviewSoupPropertiesField, SoupForeignEntity, SoupInitiativeSoupPropertiesField, SoupItem, SoupLabel, SoupLabelListVisibility, SoupLabelType, SoupMessageAttachment, SoupMessageListVisibility, SoupMessageSender, SoupMessageSenderType, SoupPage, SoupProjectSoupPropertiesField, SoupPropertiesField, SoupProperty, SoupThreadInfo, SoupThreadReply, SourceBinding, SourceId, SourceIdentity, SqlCell, SqlEntityKind, SqlOutcome, SqlOutcomeKind, SqlSelectOption, SqlStatement, StarterDatabase, StarterDocumentsResponse, StorageRow, StorageRows, StorageRowsQuery, StoredGithubPullRequest, StreamEventsData, StreamEventsError, StreamEventsErrors, StreamEventsResponse, StreamEventsResponses, String, Submission, SubmissionOutcome, SubmitFormResponseData, SubmitFormResponseError, SubmitFormResponseErrors, SubmitFormResponseResponse, SubmitFormResponseResponses, SuccessResponse, SurfaceState, SyncServiceVersionId, SystemSkillSummary, Table, TableChange, TableChanged, TableChanges, TableDetail, TableId, TableResult, TableVersion, TagFilterMode, TakenId, TallyBucket, TallyValue, TaskFilters, TaskSimilarityResult, TaskSimilaritySearchHandlerData, TaskSimilaritySearchHandlerError, TaskSimilaritySearchHandlerErrors, TaskSimilaritySearchHandlerResponse, TaskSimilaritySearchHandlerResponses, TaskSimilaritySearchRequest, TaskSimilaritySearchResponse, TeamCalendarContent, TeamCalendarCoverage, TeamCalendarDetails, TeamCalendarItem, TeamCalendarMember, TeamCalendarPage, TeamCalendarSharing, TeamOutOfOfficeItem, TeamOutOfOfficeResponse, TeamRole, TextOperator, ThreadAnchor, ThreadOrigin, ThreadPatch, ThreadState, TimelineActivity, ToggleShareWithTeamData, ToggleShareWithTeamError, ToggleShareWithTeamErrors, ToggleShareWithTeamResponse, ToggleShareWithTeamResponses, TouchedColumn, TouchedRow, TranscribeDictationData, TranscribeDictationError, TranscribeDictationErrors, TranscribeDictationResponse, TranscribeDictationResponses, TranscribeResponse, TranscriptSegmentRequest, TrashCrmPipelineData, TrashCrmPipelineResponse, TrashCrmPipelineResponses, TrashPipeline, TurnEndedMetadata, TurnStartedMetadata, TurnSummary, TypedSuccessResponse, TypedSuccessResponseGetDocumentResponseData, TypingInput, UnblockCrmDomainData, UnblockCrmDomainError, UnblockCrmDomainErrors, UnblockCrmDomainResponse, UnblockCrmDomainResponses, UndoChangeResponse, UndoDatabaseChangeData, UndoDatabaseChangeError, UndoDatabaseChangeErrors, UndoDatabaseChangeResponse, UndoDatabaseChangeResponses, UndoOutcome, UndoRefusal, UnlockedBooking, UpdateAgentData, UpdateAgentError, UpdateAgentErrors, UpdateAgentRequest, UpdateAgentResponse, UpdateAgentResponses, UpdateChannelSharePermission, UpdateCrmPipelinePermissionsData, UpdateCrmPipelinePermissionsResponse, UpdateCrmPipelinePermissionsResponses, UpdateCrmTeamSettingsRequest, UpdateDatabasePermissionsData, UpdateDatabasePermissionsError, UpdateDatabasePermissionsErrors, UpdateDatabasePermissionsResponse, UpdateDatabasePermissionsResponses, UpdateForm, UpdateFormData, UpdateFormError, UpdateFormErrors, UpdateFormPermissionsData, UpdateFormPermissionsError, UpdateFormPermissionsErrors, UpdateFormPermissionsResponse, UpdateFormPermissionsResponses, UpdateFormResponse, UpdateFormResponses, UpdateInitiativeData, UpdateInitiativeError, UpdateInitiativeErrors, UpdateInitiativeRequest, UpdateInitiativeResponse, UpdateInitiativeResponses, UpdateMeetingRequest, UpdateOperation, UpdateSharePermissionRequestV2, UploadDescriptor, UploadDocumentStatus, UploadExtractFolderHandlerData, UploadExtractFolderHandlerError, UploadExtractFolderHandlerErrors, UploadExtractFolderHandlerResponse, UploadExtractFolderHandlerResponses, UploadExtractFolderRequest, UploadFolderHandlerData, UploadFolderHandlerError, UploadFolderHandlerErrors, UploadFolderHandlerResponse, UploadFolderHandlerResponses, UploadFolderRequest, UploadGrant, UploadId, UpsertHistoryHandlerData, UpsertHistoryHandlerError, UpsertHistoryHandlerErrors, UpsertHistoryHandlerResponse, UpsertHistoryHandlerResponses, UpsertUserDocumentViewLocationData, UpsertUserDocumentViewLocationError, UpsertUserDocumentViewLocationErrors, UpsertUserDocumentViewLocationRequest, UpsertUserDocumentViewLocationResponse, UpsertUserDocumentViewLocationResponses, UserApiKeyId, UserApiKeyInfo, UserApiKeysList, UserDocumentsResponse, UserDocumentViewLocation, UserDocumentViewLocationResponse, UserPinsResponse, UserViewsResponse, ValidateDocumentPermissionsTokenData, ValidateDocumentPermissionsTokenError, ValidateDocumentPermissionsTokenErrors, ValidateDocumentPermissionsTokenResponse, ValidateDocumentPermissionsTokenResponses, ValidateWebhookData, ValidateWebhookError, ValidateWebhookErrors, ValidateWebhookResponse, ValidateWebhookResponse2, ValidateWebhookResponses, Vec, VersionedTable, View, ViewChange, ViewColumn, ViewerCapabilities, ViewLayout, ViewPatch, ViewPosition, ViewPositionsResponse, ViewQuery, ViewResult, ViewsResponse, WaitingForInputMetadata, Webhook, WebhookEvent, WebhookFilter, WebhookScope, WebhookStatus, WebhookValidationTestEvent, WhatsAppAccount, WhatsappAccountData, WhatsappAccountResponse, WhatsappAccountResponses, WhatsAppAccountState, WhatsAppAccountView, WhatsappCancelPairingData, WhatsappCancelPairingResponse, WhatsappCancelPairingResponses, WhatsAppCannotAdd, WhatsAppChat, WhatsAppChats, WhatsappChatsData, WhatsappChatsResponse, WhatsappChatsResponses, WhatsAppConnect, WhatsappConnectData, WhatsappConnectResponse, WhatsappConnectResponses, WhatsAppDisconnect, WhatsappDisconnectData, WhatsAppDisconnectRequest, WhatsappDisconnectResponse, WhatsappDisconnectResponses, WhatsAppHistoryImport, WhatsappImportHistoryData, WhatsappImportHistoryResponse, WhatsappImportHistoryResponses, WhatsAppLookup, WhatsappLookupData, WhatsAppLookupRequest, WhatsappLookupResponse, WhatsappLookupResponses, WhatsAppLookupState, WhatsAppPairing, WhatsappPairingData, WhatsappPairingResponse, WhatsappPairingResponses, WhatsAppPairingState, WhatsAppPairState, WhatsappPasskeyData, WhatsappPasskeyResponse, WhatsappPasskeyResponses, WhatsappStartLookupData, WhatsappStartLookupResponse, WhatsappStartLookupResponses, Widget, WithCallId, WithChannelId, WithDocumentId, WithProjectId } from './types.gen';diff --git a/packages/sdk/generated/storage/sdk.gen.ts b/packages/sdk/generated/storage/sdk.gen.tsindex 66ed571647..fc4d545189 100644--- a/packages/sdk/generated/storage/sdk.gen.ts+++ b/packages/sdk/generated/storage/sdk.gen.ts@@ -2,7 +2,7 @@import { type Client, type ClientMeta, formDataBodySerializer, type Options as Options2, type RequestResult, type ServerSentEventsResult, type TDataShape } from './client';import { client } from './client.gen';-import type { AccessRequestsCancelData, AccessRequestsCancelErrors, AccessRequestsCancelResponses, AccessRequestsDirectData, AccessRequestsDirectErrors, AccessRequestsDirectResponses, AccessRequestsRemoveDirectData, AccessRequestsRemoveDirectErrors, AccessRequestsRemoveDirectResponses, AccessRequestsResolveData, AccessRequestsResolveErrors, AccessRequestsResolveResponses, AccessRequestsSetDirectData, AccessRequestsSetDirectErrors, AccessRequestsSetDirectResponses, AccessRequestsStateData, AccessRequestsStateErrors, AccessRequestsStateResponses, AccessRequestsSubmitData, AccessRequestsSubmitErrors, AccessRequestsSubmitResponses, AddFavoriteData, AddFavoriteErrors, AddFavoriteResponses, AddParticipantsData, AddParticipantsErrors, AddParticipantsResponses, AddPinHandlerData, AddPinHandlerErrors, AddPinHandlerResponses, ApplyCrmPipelineOpsData, ApplyCrmPipelineOpsResponses, ApplyDatabaseOpsData, ApplyDatabaseOpsErrors, ApplyDatabaseOpsResponses, ApproveHarnessPairingData, ApproveHarnessPairingErrors, ApproveHarnessPairingResponses, BlockCrmDomainData, BlockCrmDomainErrors, BlockCrmDomainResponses, BulkWakeupSyncServiceDocumentsData, BulkWakeupSyncServiceDocumentsErrors, BulkWakeupSyncServiceDocumentsResponses, CallWebhookData, CallWebhookErrors, CallWebhookResponses, CancelSlackImportData, CancelSlackImportErrors, CancelSlackImportResponses, CheckActiveCallData, CheckActiveCallErrors, CheckActiveCallResponses, ClaimHarnessPairingData, ClaimHarnessPairingErrors, ClaimHarnessPairingResponses, CollaborateFormData, CollaborateFormErrors, CollaborateFormResponses, CompleteSlackImportUploadsData, CompleteSlackImportUploadsErrors, CompleteSlackImportUploadsResponses, ConvertDatabaseColumnData, ConvertDatabaseColumnErrors, ConvertDatabaseColumnResponses, CopyDocumentData, CopyDocumentErrors, CopyDocumentResponses, CreateAgentData, CreateAgentErrors, CreateAgentResponses, CreateAnchorData, CreateAnchorErrors, CreateAnchorResponses, CreateCanvasHandlerData, CreateCanvasHandlerErrors, CreateCanvasHandlerResponses, CreateChannelData, CreateChannelErrors, CreateChannelLabelData, CreateChannelLabelErrors, CreateChannelLabelResponses, CreateChannelResponses, CreateChannelScopedBotData, CreateChannelScopedBotErrors, CreateChannelScopedBotResponses, CreateCollabSurfaceTokenData, CreateCollabSurfaceTokenErrors, CreateCollabSurfaceTokenResponses, CreateCrmCompanyData, CreateCrmCompanyErrors, CreateCrmCompanyResponses, CreateCrmContactData, CreateCrmContactErrors, CreateCrmContactResponses, CreateCrmPipelineData, CreateCrmPipelineResponses, CreateCrmTeamContactData, CreateCrmTeamContactErrors, CreateCrmTeamContactResponses, CreateDatabaseData, CreateDatabaseErrors, CreateDatabaseResponses, CreateDatabaseWebhookData, CreateDatabaseWebhookErrors, CreateDatabaseWebhookResponses, CreateDocumentData, CreateDocumentErrors, CreateDocumentResponses, CreateEntityMentionData, CreateEntityMentionErrors, CreateEntityMentionResponses, CreateFormData, CreateFormErrors, CreateFormResponses, CreateHarnessPairingData, CreateHarnessPairingErrors, CreateHarnessPairingResponses, CreateInitiativeData, CreateInitiativeErrors, CreateInitiativeResponses, CreateInstructionsHandlerData, CreateInstructionsHandlerErrors, CreateInstructionsHandlerResponses, CreateMarkdownHandlerData, CreateMarkdownHandlerErrors, CreateMarkdownHandlerResponses, CreateProjectHandlerData, CreateProjectHandlerErrors, CreateProjectHandlerResponses, CreateSkillHandlerData, CreateSkillHandlerErrors, CreateSkillHandlerResponses, CreateSlackImportData, CreateSlackImportErrors, CreateSlackImportResponses, CreateSnippetHandlerData, CreateSnippetHandlerErrors, CreateSnippetHandlerResponses, CreateTaskHandlerData, CreateTaskHandlerErrors, CreateTaskHandlerResponses, CreateUserApiKeyData, CreateUserApiKeyErrors, CreateUserApiKeyResponses, CreateViewHandlerData, CreateViewHandlerErrors, CreateViewHandlerResponses, CreateWebhookData, CreateWebhookErrors, CreateWebhookResponses, DeclineCallData, DeclineCallErrors, DeclineCallResponses, DeclineRingData, DeclineRingErrors, DeclineRingResponses, DeleteAnchorData, DeleteAnchorErrors, DeleteAnchorResponses, DeleteCallRecordData, DeleteCallRecordErrors, DeleteCallRecordResponses, DeleteChannelData, DeleteChannelErrors, DeleteChannelLabelData, DeleteChannelLabelErrors, DeleteChannelLabelResponses, DeleteChannelResponses, DeleteCollabSurfaceData, DeleteCollabSurfaceErrors, DeleteCollabSurfaceResponses, DeleteDatabaseWebhookData, DeleteDatabaseWebhookErrors, DeleteDatabaseWebhookResponses, DeleteDocumentData, DeleteDocumentErrors, DeleteDocumentResponses, DeleteEntityMentionData, DeleteEntityMentionErrors, DeleteEntityMentionResponses, DeleteHarnessData, DeleteHarnessErrors, DeleteHarnessResponses, DeleteHistoryHandlerData, DeleteHistoryHandlerErrors, DeleteHistoryHandlerResponses, DeleteInitiativeData, DeleteInitiativeErrors, DeleteInitiativeResponses, DeleteProjectHandlerData, DeleteProjectHandlerErrors, DeleteProjectHandlerResponses, DeleteSelfHarnessData, DeleteSelfHarnessErrors, DeleteSelfHarnessResponses, DeleteUserApiKeyData, DeleteUserApiKeyErrors, DeleteUserApiKeyResponses, DeleteUserDocumentViewLocationData, DeleteUserDocumentViewLocationErrors, DeleteUserDocumentViewLocationResponses, DeleteViewHandlerData, DeleteViewHandlerErrors, DeleteViewHandlerResponses, DeleteWebhookData, DeleteWebhookErrors, DeleteWebhookResponses, DeliverDatabaseWebhookData, DeliverDatabaseWebhookErrors, DeliverDatabaseWebhookResponses, DuplicateDatabaseData, DuplicateDatabaseErrors, DuplicateDatabaseResponses, EditAnchorData, EditAnchorErrors, EditAnchorResponses, EditCallRecordData, EditCallRecordErrors, EditCallRecordResponses, EditCallTranscriptData, EditCallTranscriptErrors, EditCallTranscriptResponses, EditDocumentData, EditDocumentErrors, EditDocumentResponses, EditDocumentWithAiData, EditDocumentWithAiErrors, EditDocumentWithAiResponses, EditMyFormResponseData, EditMyFormResponseErrors, EditMyFormResponseResponses, EditProjectV2Data, EditProjectV2Errors, EditProjectV2Responses, EditThreadV2Data, EditThreadV2Errors, EditThreadV2Responses, EnsureCollabSurfaceData, EnsureCollabSurfaceErrors, EnsureCollabSurfaceResponses, EnsureStarterHandlerData, EnsureStarterHandlerErrors, EnsureStarterHandlerResponses, EntityMessageCreateData, EntityMessageCreateResponses, EntityMessageDeleteMessageData, EntityMessageDeleteMessageResponses, EntityMessageDeleteThreadData, EntityMessageDeleteThreadResponses, EntityMessageEditData, EntityMessageEditResponses, EntityMessageGetMessageData, EntityMessageGetMessageResponses, EntityMessageGetThreadData, EntityMessageGetThreadResponses, EntityMessageLegacyData, EntityMessageLegacyResponses, EntityMessagePatchThreadData, EntityMessagePatchThreadResponses, EntityMessageReactData, EntityMessageReactResponses, EntityMessageTypingData, EntityMessageTypingResponses, EventIcsData, EventIcsErrors, EventIcsResponses, ExcludeDefaultViewHandlerData, ExcludeDefaultViewHandlerErrors, ExcludeDefaultViewHandlerResponses, ExportDocumentData, ExportDocumentErrors, ExportDocumentResponses, ExternalChatAddData, ExternalChatAddResponses, ExternalChatData, ExternalChatDeliveryData, ExternalChatDeliveryResponses, ExternalChatMessageAttachmentsData, ExternalChatMessageAttachmentsResponses, ExternalChatMessageData, ExternalChatMessageResponses, ExternalChatMessagesData, ExternalChatMessagesResponses, ExternalChatPermissionsData, ExternalChatPermissionsResponses, ExternalChatReadData, ExternalChatReadResponses, ExternalChatRemoveData, ExternalChatRemoveResponses, ExternalChatResponses, ExternalChatsData, ExternalChatSendData, ExternalChatSendErrors, ExternalChatSendResponses, ExternalChatSendsData, ExternalChatSendsResponses, ExternalChatsResponses, ExternalChatUpdatePermissionsData, ExternalChatUpdatePermissionsResponses, ExternalChatUploadData, ExternalChatUploadResponses, FinalizeSlackImportData, FinalizeSlackImportErrors, FinalizeSlackImportResponses, GetActiveCallsData, GetActiveCallsErrors, GetActiveCallsResponses, GetActivityData, GetActivityErrors, GetActivityResponses, GetAttachmentReferencesData, GetAttachmentReferencesErrors, GetAttachmentReferencesResponses, GetBatchCallRecordPreviewData, GetBatchCallRecordPreviewErrors, GetBatchCallRecordPreviewResponses, GetBatchChannelPreviewData, GetBatchChannelPreviewErrors, GetBatchChannelPreviewResponses, GetBatchPreviewHandlerData, GetBatchPreviewHandlerErrors, GetBatchPreviewHandlerResponses, GetBatchProjectPreviewData, GetBatchProjectPreviewErrors, GetBatchProjectPreviewResponses, GetBotOwnerProfilesData, GetBotOwnerProfilesErrors, GetBotOwnerProfilesResponses, GetCallRecordData, GetCallRecordErrors, GetCallRecordResponses, GetChannelAttachmentsData, GetChannelAttachmentsErrors, GetChannelAttachmentsResponses, GetChannelData, GetChannelErrors, GetChannelJoinLinkData, GetChannelJoinLinkErrors, GetChannelJoinLinkResponses, GetChannelParticipantsData, GetChannelParticipantsErrors, GetChannelParticipantsResponses, GetChannelResponses, GetChannelsData, GetChannelsErrors, GetChannelsResponses, GetCollabSurfaceData, GetCollabSurfaceErrors, GetCollabSurfaceResponses, GetCompanyData, GetCompanyErrors, GetCompanyResponses, GetContactByEmailData, GetContactByEmailErrors, GetContactByEmailResponses, GetContactData, GetContactErrors, GetContactResponses, GetCrmPipelineData, GetCrmPipelinePermissionsData, GetCrmPipelinePermissionsResponses, GetCrmPipelineResponses, GetCrmPipelineRowsData, GetCrmPipelineRowsResponses, GetCrmPipelineTableData, GetCrmPipelineTableResponses, GetCrmPipelineViewPositionsData, GetCrmPipelineViewPositionsResponses, GetCrmTeamSettingsData, GetCrmTeamSettingsErrors, GetCrmTeamSettingsResponses, GetDatabaseData, GetDatabaseErrors, GetDatabasePermissionsData, GetDatabasePermissionsErrors, GetDatabasePermissionsResponses, GetDatabaseQueryData, GetDatabaseQueryErrors, GetDatabaseQueryResponses, GetDatabaseResponses, GetDatabaseRowHistoryData, GetDatabaseRowHistoryErrors, GetDatabaseRowHistoryResponses, GetDatabaseTableChangesData, GetDatabaseTableChangesErrors, GetDatabaseTableChangesResponses, GetDatabaseViewPositionsData, GetDatabaseViewPositionsErrors, GetDatabaseViewPositionsResponses, GetDocumentAnchorsData, GetDocumentAnchorsErrors, GetDocumentAnchorsResponses, GetDocumentBranchNameData, GetDocumentBranchNameErrors, GetDocumentBranchNameResponses, GetDocumentByTeamSlugData, GetDocumentByTeamSlugErrors, GetDocumentByTeamSlugResponses, GetDocumentData, GetDocumentErrors, GetDocumentGithubPullRequestsData, GetDocumentGithubPullRequestsErrors, GetDocumentGithubPullRequestsResponses, GetDocumentListHandlerData, GetDocumentListHandlerErrors, GetDocumentListHandlerResponses, GetDocumentLocationV3Data, GetDocumentLocationV3Errors, GetDocumentLocationV3Responses, GetDocumentPermissionsTokenData, GetDocumentPermissionsTokenErrors, GetDocumentPermissionsTokenResponses, GetDocumentPermissionsV2Data, GetDocumentPermissionsV2Errors, GetDocumentPermissionsV2Responses, GetDocumentProcessingResultData, GetDocumentProcessingResultErrors, GetDocumentProcessingResultResponses, GetDocumentResponses, GetDocumentShortIdData, GetDocumentShortIdErrors, GetDocumentShortIdResponses, GetDocumentTeamShareData, GetDocumentTeamShareErrors, GetDocumentTeamShareResponses, GetDocumentTextContentData, GetDocumentTextContentErrors, GetDocumentTextContentResponses, GetDocumentVersionData, GetDocumentVersionErrors, GetDocumentVersionResponses, GetDocumentViewsHandlerData, GetDocumentViewsHandlerErrors, GetDocumentViewsHandlerResponses, GetEmailFollowupData, GetEmailFollowupErrors, GetEmailFollowupResponses, GetEntityPermissionData, GetEntityPermissionErrors, GetEntityPermissionResponses, GetForeignEntityBySourceData, GetForeignEntityBySourceErrors, GetForeignEntityBySourceResponses, GetForeignEntityData, GetForeignEntityErrors, GetForeignEntityResponses, GetFormData, GetFormErrors, GetFormPermissionsData, GetFormPermissionsErrors, GetFormPermissionsResponses, GetFormResponses, GetFormResponseSummaryData, GetFormResponseSummaryErrors, GetFormResponseSummaryResponses, GetFormTallyData, GetFormTallyErrors, GetFormTallyResponses, GetGithubPullRequestChangesData, GetGithubPullRequestChangesErrors, GetGithubPullRequestChangesPatchData, GetGithubPullRequestChangesPatchErrors, GetGithubPullRequestChangesPatchResponses, GetGithubPullRequestChangesResponses, GetGithubPullRequestData, GetGithubPullRequestErrors, GetGithubPullRequestFacetsData, GetGithubPullRequestFacetsErrors, GetGithubPullRequestFacetsResponses, GetGithubPullRequestResponses, GetGithubPullRequestTasksData, GetGithubPullRequestTasksErrors, GetGithubPullRequestTasksResponses, GetHarnessPairingData, GetHarnessPairingErrors, GetHarnessPairingResponses, GetHistoryHandlerData, GetHistoryHandlerErrors, GetHistoryHandlerResponses, GetInitiativeData, GetInitiativeErrors, GetInitiativeResponses, GetInstructionsHandlerData, GetInstructionsHandlerErrors, GetInstructionsHandlerResponses, GetItemsSoupData, GetItemsSoupErrors, GetItemsSoupResponses, GetLocationHandlerData, GetLocationHandlerErrors, GetLocationHandlerResponses, GetMyFormResponseData, GetMyFormResponseErrors, GetMyFormResponseResponses, GetOrCreateCallData, GetOrCreateCallErrors, GetOrCreateCallResponses, GetOrCreateDmData, GetOrCreateDmErrors, GetOrCreateDmResponses, GetOrCreatePrivateData, GetOrCreatePrivateErrors, GetOrCreatePrivateResponses, GetPendingProjectsHandlerData, GetPendingProjectsHandlerErrors, GetPendingProjectsHandlerResponses, GetPinsHandlerData, GetPinsHandlerErrors, GetPinsHandlerResponses, GetProjectContentHandlerData, GetProjectContentHandlerErrors, GetProjectContentHandlerResponses, GetProjectHandlerData, GetProjectHandlerErrors, GetProjectHandlerResponses, GetProjectPermissionsV2Data, GetProjectPermissionsV2Errors, GetProjectPermissionsV2Responses, GetProjectsHandlerData, GetProjectsHandlerErrors, GetProjectsHandlerResponses, GetProjectUserAccessLevelData, GetProjectUserAccessLevelErrors, GetProjectUserAccessLevelResponses, GetRingStatusData, GetRingStatusErrors, GetRingStatusResponses, GetSelfBotData, GetSelfBotErrors, GetSelfBotResponses, GetSelfHarnessData, GetSelfHarnessErrors, GetSelfHarnessResponses, GetSlackImportData, GetSlackImportErrors, GetSlackImportResponses, GetSystemSkillsHandlerData, GetSystemSkillsHandlerErrors, GetSystemSkillsHandlerResponses, GetUserDocumentsHandlerData, GetUserDocumentsHandlerErrors, GetUserDocumentsHandlerResponses, GetUserDocumentViewLocationData, GetUserDocumentViewLocationErrors, GetUserDocumentViewLocationResponses, GetViewsHandlerData, GetViewsHandlerErrors, GetViewsHandlerResponses, GetWebhookData, GetWebhookErrors, GetWebhookResponses, GuestCallChatPostData, GuestCallChatPostErrors, GuestCallChatPostResponses, GuestCallChatReadData, GuestCallChatReadErrors, GuestCallChatReadResponses, HandlerData, HandlerErrors, HandlerResponses, HealthHandlerData, HealthHandlerResponses, ImportDatabaseTableData, ImportDatabaseTableErrors, ImportDatabaseTableResponses, InferDatabaseColumnTypeData, InferDatabaseColumnTypeErrors, InferDatabaseColumnTypeResponses, IngestTranscriptData, IngestTranscriptErrors, IngestTranscriptResponses, InitializeUserDocumentsData, InitializeUserDocumentsErrors, InitializeUserDocumentsResponses, InstallSyncData, InstallSyncErrors, JobProcessingResultHandlerData, JobProcessingResultHandlerErrors, JobProcessingResultHandlerResponses, JoinChannelByCodeData, JoinChannelByCodeErrors, JoinChannelByCodeResponses, JoinChannelData, JoinChannelErrors, JoinChannelResponses, LeaveChannelData, LeaveChannelErrors, LeaveChannelResponses, LeaveOrEndCallData, LeaveOrEndCallErrors, LeaveOrEndCallResponses, ListAccessibleFormsData, ListAccessibleFormsErrors, ListAccessibleFormsResponses, ListAgentsData, ListAgentsErrors, ListAgentsResponses, ListBotChannelsData, ListBotChannelsErrors, ListBotChannelsResponses, ListChannelLabelsData, ListChannelLabelsErrors, ListChannelLabelsResponses, ListCompanyContactsData, ListCompanyContactsErrors, ListCompanyContactsResponses, ListCrmBlockedDomainsData, ListCrmBlockedDomainsErrors, ListCrmBlockedDomainsResponses, ListCrmPipelinesData, ListCrmPipelinesResponses, ListDatabaseColumnCastsData, ListDatabaseColumnCastsErrors, ListDatabaseColumnCastsResponses, ListDatabasesData, ListDatabasesErrors, ListDatabasesResponses, ListDatabaseWebhooksData, ListDatabaseWebhooksErrors, ListDatabaseWebhooksResponses, ListEmailRemindersData, ListEmailRemindersErrors, ListEmailRemindersResponses, ListFavoritesData, ListFavoritesErrors, ListFavoritesResponses, ListFormsData, ListFormsErrors, ListFormsResponses, ListHarnessAgentsData, ListHarnessAgentsErrors, ListHarnessAgentsResponses, ListHarnessesData, ListHarnessesErrors, ListHarnessesResponses, ListHarnessSessionsData, ListHarnessSessionsErrors, ListHarnessSessionsResponses, ListInitiativesData, ListInitiativesErrors, ListInitiativesResponses, ListJoinRequestsData, ListJoinRequestsErrors, ListJoinRequestsResponses, ListOccurrencesData, ListOccurrencesErrors, ListOccurrencesResponses, ListSlackImportsData, ListSlackImportsResponses, ListTeamCalendarData, ListTeamCalendarResponses, ListTeamOutOfOfficeData, ListTeamOutOfOfficeErrors, ListTeamOutOfOfficeResponses, ListUserApiKeysData, ListUserApiKeysErrors, ListUserApiKeysResponses, ListWebhooksData, ListWebhooksErrors, ListWebhooksResponses, MeetingCancelData, MeetingCancelErrors, MeetingCancelPreparationData, MeetingCancelPreparationErrors, MeetingCancelPreparationResponses, MeetingCancelResponses, MeetingCreateData, MeetingCreateErrors, MeetingCreateResponses, MeetingGuestJoinData, MeetingGuestJoinErrors, MeetingGuestJoinResponses, MeetingGuestParticipantsData, MeetingGuestParticipantsErrors, MeetingGuestParticipantsResponses, MeetingInviteData, MeetingInviteErrors, MeetingInvitePermissionsData, MeetingInvitePermissionsErrors, MeetingInvitePermissionsResponses, MeetingInviteResponses, MeetingInviteUsersData, MeetingInviteUsersErrors, MeetingInviteUsersResponses, MeetingJoinData, MeetingJoinErrors, MeetingJoinResponses, MeetingLeaveData, MeetingLeaveErrors, MeetingLeaveResponses, MeetingListActiveData, MeetingListActiveErrors, MeetingListActiveResponses, MeetingListData, MeetingListErrors, MeetingListResponses, MeetingLookupData, MeetingLookupErrors, MeetingLookupResponses, MeetingParticipantsData, MeetingParticipantsErrors, MeetingParticipantsResponses, MeetingPrepareData, MeetingPrepareErrors, MeetingPrepareResponses, MeetingShareData, MeetingShareErrors, MeetingShareResponses, MeetingUpdateData, MeetingUpdateErrors, MeetingUpdateResponses, MentionPreviewsData, MentionPreviewsErrors, MentionPreviewsResponses, MessageTimelineData, MessageTimelineEntriesData, MessageTimelineEntriesResponses, MessageTimelineResponses, PatchChannelData, PatchChannelErrors, PatchChannelResponses, PatchViewHandlerData, PatchViewHandlerErrors, PatchViewHandlerResponses, PatchWebhookData, PatchWebhookErrors, PatchWebhookResponses, PermanentlyDeleteDocumentData, PermanentlyDeleteDocumentErrors, PermanentlyDeleteDocumentResponses, PermanentlyDeleteProjectData, PermanentlyDeleteProjectErrors, PermanentlyDeleteProjectResponses, PostActivityData, PostActivityErrors, PostActivityResponses, PostChannelBotWebhookData, PostChannelBotWebhookErrors, PostChannelBotWebhookResponses, PostItemsSoupAstData, PostItemsSoupAstErrors, PostItemsSoupAstGroupedData, PostItemsSoupAstGroupedErrors, PostItemsSoupAstGroupedResponses, PostItemsSoupAstResponses, PostItemsSoupData, PostItemsSoupErrors, PostItemsSoupResponses, PresaveDocumentHandlerData, PresaveDocumentHandlerErrors, PresaveDocumentHandlerResponses, PreviewSmartTagData, PreviewSmartTagErrors, PreviewSmartTagResponses, PutCrmTeamSettingsData, PutCrmTeamSettingsErrors, PutCrmTeamSettingsResponses, PutCrmTeamStagesData, PutCrmTeamStagesErrors, PutCrmTeamStagesResponses, PutFormLayoutData, PutFormLayoutErrors, PutFormLayoutResponses, QueryCrmPipelineRowsData, QueryCrmPipelineRowsResponses, QueryDatabasesData, QueryDatabasesErrors, QueryDatabasesResponses, RecentlyDeletedData, RecentlyDeletedErrors, RecentlyDeletedResponses, RegisterSlackImportUploadsData, RegisterSlackImportUploadsErrors, RegisterSlackImportUploadsResponses, RemoveBotFromChannelByBotData, RemoveBotFromChannelByBotErrors, RemoveBotFromChannelByBotResponses, RemoveFavoriteByEntityData, RemoveFavoriteByEntityErrors, RemoveFavoriteByEntityResponses, RemoveParticipantsData, RemoveParticipantsErrors, RemoveParticipantsResponses, RemovePinHandlerData, RemovePinHandlerErrors, RemovePinHandlerResponses, RenameChannelLabelData, RenameChannelLabelErrors, RenameChannelLabelResponses, RenameCrmPipelineData, RenameCrmPipelineResponses, ReorderFavoritesData, ReorderFavoritesErrors, ReorderFavoritesResponses, ReorderPinsHandlerData, ReorderPinsHandlerErrors, ReorderPinsHandlerResponses, RequestToJoinData, RequestToJoinErrors, RequestToJoinResponses, ResetCrmTeamStagesData, ResetCrmTeamStagesErrors, ResetCrmTeamStagesResponses, RevertDeleteDocumentData, RevertDeleteDocumentErrors, RevertDeleteDocumentResponses, RevertDeleteProjectData, RevertDeleteProjectErrors, RevertDeleteProjectResponses, SaveDatabaseQueryData, SaveDatabaseQueryErrors, SaveDatabaseQueryResponses, SaveDocumentHandlerData, SaveDocumentHandlerErrors, SaveDocumentHandlerResponses, SearchContactsData, SearchContactsErrors, SearchContactsResponses, SetChannelLabelData, SetChannelLabelErrors, SetChannelLabelResponses, SetChannelPictureData, SetChannelPictureErrors, SetChannelPictureResponses, SetCompanyHiddenData, SetCompanyHiddenErrors, SetCompanyHiddenResponses, SetContactHiddenData, SetContactHiddenErrors, SetContactHiddenResponses, SetCrmCompanyNameData, SetCrmCompanyNameErrors, SetCrmCompanyNameResponses, SetCrmContactNameData, SetCrmContactNameErrors, SetCrmContactNameResponses, SetDocumentTeamShareData, SetDocumentTeamShareErrors, SetDocumentTeamShareResponses, SetEmailFollowupData, SetEmailFollowupErrors, SetEmailFollowupResponses, SetEmailSyncData, SetEmailSyncErrors, SetEmailSyncResponses, ShareCrmPipelineData, ShareCrmPipelineResponses, ShareDatabaseAwarenessData, ShareDatabaseAwarenessErrors, ShareDatabaseAwarenessResponses, SimpleSaveData, SimpleSaveErrors, SimpleSaveResponses, StreamEventsData, StreamEventsErrors, StreamEventsResponse, StreamEventsResponses, SubmitFormResponseData, SubmitFormResponseErrors, SubmitFormResponseResponses, TaskSimilaritySearchHandlerData, TaskSimilaritySearchHandlerErrors, TaskSimilaritySearchHandlerResponses, ToggleShareWithTeamData, ToggleShareWithTeamErrors, ToggleShareWithTeamResponses, TranscribeDictationData, TranscribeDictationErrors, TranscribeDictationResponses, TrashCrmPipelineData, TrashCrmPipelineResponses, UnblockCrmDomainData, UnblockCrmDomainErrors, UnblockCrmDomainResponses, UndoDatabaseChangeData, UndoDatabaseChangeErrors, UndoDatabaseChangeResponses, UpdateAgentData, UpdateAgentErrors, UpdateAgentResponses, UpdateCrmPipelinePermissionsData, UpdateCrmPipelinePermissionsResponses, UpdateDatabasePermissionsData, UpdateDatabasePermissionsErrors, UpdateDatabasePermissionsResponses, UpdateFormData, UpdateFormErrors, UpdateFormPermissionsData, UpdateFormPermissionsErrors, UpdateFormPermissionsResponses, UpdateFormResponses, UpdateInitiativeData, UpdateInitiativeErrors, UpdateInitiativeResponses, UploadExtractFolderHandlerData, UploadExtractFolderHandlerErrors, UploadExtractFolderHandlerResponses, UploadFolderHandlerData, UploadFolderHandlerErrors, UploadFolderHandlerResponses, UpsertHistoryHandlerData, UpsertHistoryHandlerErrors, UpsertHistoryHandlerResponses, UpsertUserDocumentViewLocationData, UpsertUserDocumentViewLocationErrors, UpsertUserDocumentViewLocationResponses, ValidateDocumentPermissionsTokenData, ValidateDocumentPermissionsTokenErrors, ValidateDocumentPermissionsTokenResponses, ValidateWebhookData, ValidateWebhookErrors, ValidateWebhookResponses, WhatsappAccountData, WhatsappAccountResponses, WhatsappCancelPairingData, WhatsappCancelPairingResponses, WhatsappChatsData, WhatsappChatsResponses, WhatsappConnectData, WhatsappConnectResponses, WhatsappDisconnectData, WhatsappDisconnectResponses, WhatsappImportHistoryData, WhatsappImportHistoryResponses, WhatsappLookupData, WhatsappLookupResponses, WhatsappPairingData, WhatsappPairingResponses, WhatsappPasskeyData, WhatsappPasskeyResponses, WhatsappStartLookupData, WhatsappStartLookupResponses } from './types.gen';+import type { AccessRequestsCancelData, AccessRequestsCancelErrors, AccessRequestsCancelResponses, AccessRequestsDirectData, AccessRequestsDirectErrors, AccessRequestsDirectResponses, AccessRequestsRemoveDirectData, AccessRequestsRemoveDirectErrors, AccessRequestsRemoveDirectResponses, AccessRequestsResolveData, AccessRequestsResolveErrors, AccessRequestsResolveResponses, AccessRequestsSetDirectData, AccessRequestsSetDirectErrors, AccessRequestsSetDirectResponses, AccessRequestsStateData, AccessRequestsStateErrors, AccessRequestsStateResponses, AccessRequestsSubmitData, AccessRequestsSubmitErrors, AccessRequestsSubmitResponses, AddFavoriteData, AddFavoriteErrors, AddFavoriteResponses, AddParticipantsData, AddParticipantsErrors, AddParticipantsResponses, AddPinHandlerData, AddPinHandlerErrors, AddPinHandlerResponses, ApplyCrmPipelineOpsData, ApplyCrmPipelineOpsResponses, ApplyDatabaseOpsData, ApplyDatabaseOpsErrors, ApplyDatabaseOpsResponses, ApproveHarnessPairingData, ApproveHarnessPairingErrors, ApproveHarnessPairingResponses, BlockCrmDomainData, BlockCrmDomainErrors, BlockCrmDomainResponses, BulkWakeupSyncServiceDocumentsData, BulkWakeupSyncServiceDocumentsErrors, BulkWakeupSyncServiceDocumentsResponses, CallWebhookData, CallWebhookErrors, CallWebhookResponses, CancelSlackImportData, CancelSlackImportErrors, CancelSlackImportResponses, CheckActiveCallData, CheckActiveCallErrors, CheckActiveCallResponses, ClaimHarnessPairingData, ClaimHarnessPairingErrors, ClaimHarnessPairingResponses, CollaborateFormData, CollaborateFormErrors, CollaborateFormResponses, CompleteSlackImportUploadsData, CompleteSlackImportUploadsErrors, CompleteSlackImportUploadsResponses, ConvertDatabaseColumnData, ConvertDatabaseColumnErrors, ConvertDatabaseColumnResponses, CopyDocumentData, CopyDocumentErrors, CopyDocumentResponses, CreateAgentData, CreateAgentErrors, CreateAgentResponses, CreateAnchorData, CreateAnchorErrors, CreateAnchorResponses, CreateCanvasHandlerData, CreateCanvasHandlerErrors, CreateCanvasHandlerResponses, CreateChannelData, CreateChannelErrors, CreateChannelLabelData, CreateChannelLabelErrors, CreateChannelLabelResponses, CreateChannelResponses, CreateChannelScopedBotData, CreateChannelScopedBotErrors, CreateChannelScopedBotResponses, CreateCollabSurfaceTokenData, CreateCollabSurfaceTokenErrors, CreateCollabSurfaceTokenResponses, CreateCrmCompanyData, CreateCrmCompanyErrors, CreateCrmCompanyResponses, CreateCrmContactData, CreateCrmContactErrors, CreateCrmContactResponses, CreateCrmPipelineData, CreateCrmPipelineResponses, CreateCrmTeamContactData, CreateCrmTeamContactErrors, CreateCrmTeamContactResponses, CreateDatabaseData, CreateDatabaseErrors, CreateDatabaseResponses, CreateDatabaseWebhookData, CreateDatabaseWebhookErrors, CreateDatabaseWebhookResponses, CreateDocumentData, CreateDocumentErrors, CreateDocumentResponses, CreateEntityMentionData, CreateEntityMentionErrors, CreateEntityMentionResponses, CreateFormData, CreateFormErrors, CreateFormResponses, CreateHarnessPairingData, CreateHarnessPairingErrors, CreateHarnessPairingResponses, CreateInitiativeData, CreateInitiativeErrors, CreateInitiativeResponses, CreateInstructionsHandlerData, CreateInstructionsHandlerErrors, CreateInstructionsHandlerResponses, CreateMarkdownHandlerData, CreateMarkdownHandlerErrors, CreateMarkdownHandlerResponses, CreateProjectHandlerData, CreateProjectHandlerErrors, CreateProjectHandlerResponses, CreateSkillHandlerData, CreateSkillHandlerErrors, CreateSkillHandlerResponses, CreateSlackImportData, CreateSlackImportErrors, CreateSlackImportResponses, CreateSnippetHandlerData, CreateSnippetHandlerErrors, CreateSnippetHandlerResponses, CreateTaskHandlerData, CreateTaskHandlerErrors, CreateTaskHandlerResponses, CreateUserApiKeyData, CreateUserApiKeyErrors, CreateUserApiKeyResponses, CreateViewHandlerData, CreateViewHandlerErrors, CreateViewHandlerResponses, CreateWebhookData, CreateWebhookErrors, CreateWebhookResponses, DeclineCallData, DeclineCallErrors, DeclineCallResponses, DeclineRingData, DeclineRingErrors, DeclineRingResponses, DeleteAnchorData, DeleteAnchorErrors, DeleteAnchorResponses, DeleteCallRecordData, DeleteCallRecordErrors, DeleteCallRecordResponses, DeleteChannelData, DeleteChannelErrors, DeleteChannelLabelData, DeleteChannelLabelErrors, DeleteChannelLabelResponses, DeleteChannelResponses, DeleteCollabSurfaceData, DeleteCollabSurfaceErrors, DeleteCollabSurfaceResponses, DeleteDatabaseWebhookData, DeleteDatabaseWebhookErrors, DeleteDatabaseWebhookResponses, DeleteDocumentData, DeleteDocumentErrors, DeleteDocumentResponses, DeleteEntityMentionData, DeleteEntityMentionErrors, DeleteEntityMentionResponses, DeleteHarnessData, DeleteHarnessErrors, DeleteHarnessResponses, DeleteHistoryHandlerData, DeleteHistoryHandlerErrors, DeleteHistoryHandlerResponses, DeleteInitiativeData, DeleteInitiativeErrors, DeleteInitiativeResponses, DeleteProjectHandlerData, DeleteProjectHandlerErrors, DeleteProjectHandlerResponses, DeleteSelfHarnessData, DeleteSelfHarnessErrors, DeleteSelfHarnessResponses, DeleteUserApiKeyData, DeleteUserApiKeyErrors, DeleteUserApiKeyResponses, DeleteUserDocumentViewLocationData, DeleteUserDocumentViewLocationErrors, DeleteUserDocumentViewLocationResponses, DeleteViewHandlerData, DeleteViewHandlerErrors, DeleteViewHandlerResponses, DeleteWebhookData, DeleteWebhookErrors, DeleteWebhookResponses, DeliverDatabaseWebhookData, DeliverDatabaseWebhookErrors, DeliverDatabaseWebhookResponses, DuplicateDatabaseData, DuplicateDatabaseErrors, DuplicateDatabaseResponses, EditAnchorData, EditAnchorErrors, EditAnchorResponses, EditCallRecordData, EditCallRecordErrors, EditCallRecordResponses, EditCallTranscriptData, EditCallTranscriptErrors, EditCallTranscriptResponses, EditDocumentData, EditDocumentErrors, EditDocumentResponses, EditDocumentWithAiData, EditDocumentWithAiErrors, EditDocumentWithAiResponses, EditMyFormResponseData, EditMyFormResponseErrors, EditMyFormResponseResponses, EditProjectV2Data, EditProjectV2Errors, EditProjectV2Responses, EditThreadV2Data, EditThreadV2Errors, EditThreadV2Responses, EnsureCollabSurfaceData, EnsureCollabSurfaceErrors, EnsureCollabSurfaceResponses, EnsureStarterHandlerData, EnsureStarterHandlerErrors, EnsureStarterHandlerResponses, EntityMessageCreateData, EntityMessageCreateResponses, EntityMessageDeleteMessageData, EntityMessageDeleteMessageResponses, EntityMessageDeleteThreadData, EntityMessageDeleteThreadResponses, EntityMessageEditData, EntityMessageEditResponses, EntityMessageGetMessageData, EntityMessageGetMessageResponses, EntityMessageGetThreadData, EntityMessageGetThreadResponses, EntityMessageLegacyData, EntityMessageLegacyResponses, EntityMessagePatchThreadData, EntityMessagePatchThreadResponses, EntityMessageReactData, EntityMessageReactResponses, EntityMessageTypingData, EntityMessageTypingResponses, EventIcsData, EventIcsErrors, EventIcsResponses, ExcludeDefaultViewHandlerData, ExcludeDefaultViewHandlerErrors, ExcludeDefaultViewHandlerResponses, ExportDocumentData, ExportDocumentErrors, ExportDocumentResponses, ExternalChatAddData, ExternalChatAddResponses, ExternalChatData, ExternalChatDeliveryData, ExternalChatDeliveryResponses, ExternalChatMessageAttachmentsData, ExternalChatMessageAttachmentsResponses, ExternalChatMessageData, ExternalChatMessageResponses, ExternalChatMessagesData, ExternalChatMessagesResponses, ExternalChatPermissionsData, ExternalChatPermissionsResponses, ExternalChatReadData, ExternalChatReadResponses, ExternalChatRemoveData, ExternalChatRemoveResponses, ExternalChatResponses, ExternalChatsData, ExternalChatSendData, ExternalChatSendErrors, ExternalChatSendResponses, ExternalChatSendsData, ExternalChatSendsResponses, ExternalChatsResponses, ExternalChatUpdatePermissionsData, ExternalChatUpdatePermissionsResponses, ExternalChatUploadData, ExternalChatUploadResponses, FinalizeSlackImportData, FinalizeSlackImportErrors, FinalizeSlackImportResponses, GetActiveCallsData, GetActiveCallsErrors, GetActiveCallsResponses, GetActivityData, GetActivityErrors, GetActivityResponses, GetAttachmentReferencesData, GetAttachmentReferencesErrors, GetAttachmentReferencesResponses, GetBatchCallRecordPreviewData, GetBatchCallRecordPreviewErrors, GetBatchCallRecordPreviewResponses, GetBatchChannelPreviewData, GetBatchChannelPreviewErrors, GetBatchChannelPreviewResponses, GetBatchPreviewHandlerData, GetBatchPreviewHandlerErrors, GetBatchPreviewHandlerResponses, GetBatchProjectPreviewData, GetBatchProjectPreviewErrors, GetBatchProjectPreviewResponses, GetBotOwnerProfilesData, GetBotOwnerProfilesErrors, GetBotOwnerProfilesResponses, GetCallRecordData, GetCallRecordErrors, GetCallRecordResponses, GetChannelAttachmentsData, GetChannelAttachmentsErrors, GetChannelAttachmentsResponses, GetChannelData, GetChannelErrors, GetChannelJoinLinkData, GetChannelJoinLinkErrors, GetChannelJoinLinkResponses, GetChannelParticipantsData, GetChannelParticipantsErrors, GetChannelParticipantsResponses, GetChannelResponses, GetChannelsData, GetChannelsErrors, GetChannelsResponses, GetCollabSurfaceData, GetCollabSurfaceErrors, GetCollabSurfaceResponses, GetCompanyData, GetCompanyErrors, GetCompanyResponses, GetContactByEmailData, GetContactByEmailErrors, GetContactByEmailResponses, GetContactData, GetContactErrors, GetContactResponses, GetCrmPipelineData, GetCrmPipelinePermissionsData, GetCrmPipelinePermissionsResponses, GetCrmPipelineResponses, GetCrmPipelineRowsData, GetCrmPipelineRowsResponses, GetCrmPipelineTableData, GetCrmPipelineTableResponses, GetCrmPipelineViewPositionsData, GetCrmPipelineViewPositionsResponses, GetCrmTeamSettingsData, GetCrmTeamSettingsErrors, GetCrmTeamSettingsResponses, GetDatabaseData, GetDatabaseErrors, GetDatabasePermissionsData, GetDatabasePermissionsErrors, GetDatabasePermissionsResponses, GetDatabaseQueryData, GetDatabaseQueryErrors, GetDatabaseQueryResponses, GetDatabaseResponses, GetDatabaseRowHistoryData, GetDatabaseRowHistoryErrors, GetDatabaseRowHistoryResponses, GetDatabaseTableChangesData, GetDatabaseTableChangesErrors, GetDatabaseTableChangesResponses, GetDatabaseViewPositionsData, GetDatabaseViewPositionsErrors, GetDatabaseViewPositionsResponses, GetDocumentAnchorsData, GetDocumentAnchorsErrors, GetDocumentAnchorsResponses, GetDocumentBranchNameData, GetDocumentBranchNameErrors, GetDocumentBranchNameResponses, GetDocumentByTeamSlugData, GetDocumentByTeamSlugErrors, GetDocumentByTeamSlugResponses, GetDocumentData, GetDocumentErrors, GetDocumentGithubPullRequestsData, GetDocumentGithubPullRequestsErrors, GetDocumentGithubPullRequestsResponses, GetDocumentListHandlerData, GetDocumentListHandlerErrors, GetDocumentListHandlerResponses, GetDocumentLocationV3Data, GetDocumentLocationV3Errors, GetDocumentLocationV3Responses, GetDocumentPermissionsTokenData, GetDocumentPermissionsTokenErrors, GetDocumentPermissionsTokenResponses, GetDocumentPermissionsV2Data, GetDocumentPermissionsV2Errors, GetDocumentPermissionsV2Responses, GetDocumentProcessingResultData, GetDocumentProcessingResultErrors, GetDocumentProcessingResultResponses, GetDocumentResponses, GetDocumentShortIdData, GetDocumentShortIdErrors, GetDocumentShortIdResponses, GetDocumentTeamShareData, GetDocumentTeamShareErrors, GetDocumentTeamShareResponses, GetDocumentTextContentData, GetDocumentTextContentErrors, GetDocumentTextContentResponses, GetDocumentVersionData, GetDocumentVersionErrors, GetDocumentVersionResponses, GetDocumentViewsHandlerData, GetDocumentViewsHandlerErrors, GetDocumentViewsHandlerResponses, GetEmailFollowupData, GetEmailFollowupErrors, GetEmailFollowupResponses, GetEntityPermissionData, GetEntityPermissionErrors, GetEntityPermissionResponses, GetForeignEntityBySourceData, GetForeignEntityBySourceErrors, GetForeignEntityBySourceResponses, GetForeignEntityData, GetForeignEntityErrors, GetForeignEntityResponses, GetFormData, GetFormErrors, GetFormPermissionsData, GetFormPermissionsErrors, GetFormPermissionsResponses, GetFormResponses, GetFormResponseSummaryData, GetFormResponseSummaryErrors, GetFormResponseSummaryResponses, GetFormTallyData, GetFormTallyErrors, GetFormTallyResponses, GetGithubPullRequestChangesData, GetGithubPullRequestChangesErrors, GetGithubPullRequestChangesPatchData, GetGithubPullRequestChangesPatchErrors, GetGithubPullRequestChangesPatchResponses, GetGithubPullRequestChangesResponses, GetGithubPullRequestData, GetGithubPullRequestErrors, GetGithubPullRequestFacetsData, GetGithubPullRequestFacetsErrors, GetGithubPullRequestFacetsResponses, GetGithubPullRequestResponses, GetGithubPullRequestTasksData, GetGithubPullRequestTasksErrors, GetGithubPullRequestTasksResponses, GetHarnessPairingData, GetHarnessPairingErrors, GetHarnessPairingResponses, GetHistoryHandlerData, GetHistoryHandlerErrors, GetHistoryHandlerResponses, GetInitiativeData, GetInitiativeErrors, GetInitiativeResponses, GetInstructionsHandlerData, GetInstructionsHandlerErrors, GetInstructionsHandlerResponses, GetItemsSoupData, GetItemsSoupErrors, GetItemsSoupResponses, GetLocationHandlerData, GetLocationHandlerErrors, GetLocationHandlerResponses, GetMyFormResponseData, GetMyFormResponseErrors, GetMyFormResponseResponses, GetOrCreateCallData, GetOrCreateCallErrors, GetOrCreateCallResponses, GetOrCreateDmData, GetOrCreateDmErrors, GetOrCreateDmResponses, GetOrCreatePrivateData, GetOrCreatePrivateErrors, GetOrCreatePrivateResponses, GetPendingProjectsHandlerData, GetPendingProjectsHandlerErrors, GetPendingProjectsHandlerResponses, GetPinsHandlerData, GetPinsHandlerErrors, GetPinsHandlerResponses, GetProjectContentHandlerData, GetProjectContentHandlerErrors, GetProjectContentHandlerResponses, GetProjectHandlerData, GetProjectHandlerErrors, GetProjectHandlerResponses, GetProjectPermissionsV2Data, GetProjectPermissionsV2Errors, GetProjectPermissionsV2Responses, GetProjectsHandlerData, GetProjectsHandlerErrors, GetProjectsHandlerResponses, GetProjectUserAccessLevelData, GetProjectUserAccessLevelErrors, GetProjectUserAccessLevelResponses, GetRingStatusData, GetRingStatusErrors, GetRingStatusResponses, GetSelfBotData, GetSelfBotErrors, GetSelfBotResponses, GetSelfHarnessData, GetSelfHarnessErrors, GetSelfHarnessResponses, GetSkillDescriptionData, GetSkillDescriptionErrors, GetSkillDescriptionResponses, GetSlackImportData, GetSlackImportErrors, GetSlackImportResponses, GetSystemSkillsHandlerData, GetSystemSkillsHandlerErrors, GetSystemSkillsHandlerResponses, GetUserDocumentsHandlerData, GetUserDocumentsHandlerErrors, GetUserDocumentsHandlerResponses, GetUserDocumentViewLocationData, GetUserDocumentViewLocationErrors, GetUserDocumentViewLocationResponses, GetViewsHandlerData, GetViewsHandlerErrors, GetViewsHandlerResponses, GetWebhookData, GetWebhookErrors, GetWebhookResponses, GuestCallChatPostData, GuestCallChatPostErrors, GuestCallChatPostResponses, GuestCallChatReadData, GuestCallChatReadErrors, GuestCallChatReadResponses, HandlerData, HandlerErrors, HandlerResponses, HealthHandlerData, HealthHandlerResponses, ImportDatabaseTableData, ImportDatabaseTableErrors, ImportDatabaseTableResponses, InferDatabaseColumnTypeData, InferDatabaseColumnTypeErrors, InferDatabaseColumnTypeResponses, IngestTranscriptData, IngestTranscriptErrors, IngestTranscriptResponses, InitializeUserDocumentsData, InitializeUserDocumentsErrors, InitializeUserDocumentsResponses, InstallSyncData, InstallSyncErrors, JobProcessingResultHandlerData, JobProcessingResultHandlerErrors, JobProcessingResultHandlerResponses, JoinChannelByCodeData, JoinChannelByCodeErrors, JoinChannelByCodeResponses, JoinChannelData, JoinChannelErrors, JoinChannelResponses, LeaveChannelData, LeaveChannelErrors, LeaveChannelResponses, LeaveOrEndCallData, LeaveOrEndCallErrors, LeaveOrEndCallResponses, ListAccessibleFormsData, ListAccessibleFormsErrors, ListAccessibleFormsResponses, ListAgentsData, ListAgentsErrors, ListAgentsResponses, ListBotChannelsData, ListBotChannelsErrors, ListBotChannelsResponses, ListChannelLabelsData, ListChannelLabelsErrors, ListChannelLabelsResponses, ListCompanyContactsData, ListCompanyContactsErrors, ListCompanyContactsResponses, ListCrmBlockedDomainsData, ListCrmBlockedDomainsErrors, ListCrmBlockedDomainsResponses, ListCrmPipelinesData, ListCrmPipelinesResponses, ListDatabaseColumnCastsData, ListDatabaseColumnCastsErrors, ListDatabaseColumnCastsResponses, ListDatabasesData, ListDatabasesErrors, ListDatabasesResponses, ListDatabaseWebhooksData, ListDatabaseWebhooksErrors, ListDatabaseWebhooksResponses, ListEmailRemindersData, ListEmailRemindersErrors, ListEmailRemindersResponses, ListFavoritesData, ListFavoritesErrors, ListFavoritesResponses, ListFormsData, ListFormsErrors, ListFormsResponses, ListHarnessAgentsData, ListHarnessAgentsErrors, ListHarnessAgentsResponses, ListHarnessesData, ListHarnessesErrors, ListHarnessesResponses, ListHarnessSessionsData, ListHarnessSessionsErrors, ListHarnessSessionsResponses, ListInitiativesData, ListInitiativesErrors, ListInitiativesResponses, ListJoinRequestsData, ListJoinRequestsErrors, ListJoinRequestsResponses, ListOccurrencesData, ListOccurrencesErrors, ListOccurrencesResponses, ListSlackImportsData, ListSlackImportsResponses, ListTeamCalendarData, ListTeamCalendarResponses, ListTeamOutOfOfficeData, ListTeamOutOfOfficeErrors, ListTeamOutOfOfficeResponses, ListUserApiKeysData, ListUserApiKeysErrors, ListUserApiKeysResponses, ListWebhooksData, ListWebhooksErrors, ListWebhooksResponses, MeetingCancelData, MeetingCancelErrors, MeetingCancelPreparationData, MeetingCancelPreparationErrors, MeetingCancelPreparationResponses, MeetingCancelResponses, MeetingCreateData, MeetingCreateErrors, MeetingCreateResponses, MeetingGuestJoinData, MeetingGuestJoinErrors, MeetingGuestJoinResponses, MeetingGuestParticipantsData, MeetingGuestParticipantsErrors, MeetingGuestParticipantsResponses, MeetingInviteData, MeetingInviteErrors, MeetingInvitePermissionsData, MeetingInvitePermissionsErrors, MeetingInvitePermissionsResponses, MeetingInviteResponses, MeetingInviteUsersData, MeetingInviteUsersErrors, MeetingInviteUsersResponses, MeetingJoinData, MeetingJoinErrors, MeetingJoinResponses, MeetingLeaveData, MeetingLeaveErrors, MeetingLeaveResponses, MeetingListActiveData, MeetingListActiveErrors, MeetingListActiveResponses, MeetingListData, MeetingListErrors, MeetingListResponses, MeetingLookupData, MeetingLookupErrors, MeetingLookupResponses, MeetingParticipantsData, MeetingParticipantsErrors, MeetingParticipantsResponses, MeetingPrepareData, MeetingPrepareErrors, MeetingPrepareResponses, MeetingShareData, MeetingShareErrors, MeetingShareResponses, MeetingUpdateData, MeetingUpdateErrors, MeetingUpdateResponses, MentionPreviewsData, MentionPreviewsErrors, MentionPreviewsResponses, MessageTimelineData, MessageTimelineEntriesData, MessageTimelineEntriesResponses, MessageTimelineResponses, PatchChannelData, PatchChannelErrors, PatchChannelResponses, PatchViewHandlerData, PatchViewHandlerErrors, PatchViewHandlerResponses, PatchWebhookData, PatchWebhookErrors, PatchWebhookResponses, PermanentlyDeleteDocumentData, PermanentlyDeleteDocumentErrors, PermanentlyDeleteDocumentResponses, PermanentlyDeleteProjectData, PermanentlyDeleteProjectErrors, PermanentlyDeleteProjectResponses, PostActivityData, PostActivityErrors, PostActivityResponses, PostChannelBotWebhookData, PostChannelBotWebhookErrors, PostChannelBotWebhookResponses, PostItemsSoupAstData, PostItemsSoupAstErrors, PostItemsSoupAstGroupedData, PostItemsSoupAstGroupedErrors, PostItemsSoupAstGroupedResponses, PostItemsSoupAstResponses, PostItemsSoupData, PostItemsSoupErrors, PostItemsSoupResponses, PresaveDocumentHandlerData, PresaveDocumentHandlerErrors, PresaveDocumentHandlerResponses, PreviewSmartTagData, PreviewSmartTagErrors, PreviewSmartTagResponses, PutCrmTeamSettingsData, PutCrmTeamSettingsErrors, PutCrmTeamSettingsResponses, PutCrmTeamStagesData, PutCrmTeamStagesErrors, PutCrmTeamStagesResponses, PutFormLayoutData, PutFormLayoutErrors, PutFormLayoutResponses, QueryCrmPipelineRowsData, QueryCrmPipelineRowsResponses, QueryDatabasesData, QueryDatabasesErrors, QueryDatabasesResponses, RecentlyDeletedData, RecentlyDeletedErrors, RecentlyDeletedResponses, RegisterSlackImportUploadsData, RegisterSlackImportUploadsErrors, RegisterSlackImportUploadsResponses, RemoveBotFromChannelByBotData, RemoveBotFromChannelByBotErrors, RemoveBotFromChannelByBotResponses, RemoveFavoriteByEntityData, RemoveFavoriteByEntityErrors, RemoveFavoriteByEntityResponses, RemoveParticipantsData, RemoveParticipantsErrors, RemoveParticipantsResponses, RemovePinHandlerData, RemovePinHandlerErrors, RemovePinHandlerResponses, RenameChannelLabelData, RenameChannelLabelErrors, RenameChannelLabelResponses, RenameCrmPipelineData, RenameCrmPipelineResponses, ReorderFavoritesData, ReorderFavoritesErrors, ReorderFavoritesResponses, ReorderPinsHandlerData, ReorderPinsHandlerErrors, ReorderPinsHandlerResponses, RequestToJoinData, RequestToJoinErrors, RequestToJoinResponses, ResetCrmTeamStagesData, ResetCrmTeamStagesErrors, ResetCrmTeamStagesResponses, RevertDeleteDocumentData, RevertDeleteDocumentErrors, RevertDeleteDocumentResponses, RevertDeleteProjectData, RevertDeleteProjectErrors, RevertDeleteProjectResponses, SaveDatabaseQueryData, SaveDatabaseQueryErrors, SaveDatabaseQueryResponses, SaveDocumentHandlerData, SaveDocumentHandlerErrors, SaveDocumentHandlerResponses, SearchContactsData, SearchContactsErrors, SearchContactsResponses, SetChannelLabelData, SetChannelLabelErrors, SetChannelLabelResponses, SetChannelPictureData, SetChannelPictureErrors, SetChannelPictureResponses, SetCompanyHiddenData, SetCompanyHiddenErrors, SetCompanyHiddenResponses, SetContactHiddenData, SetContactHiddenErrors, SetContactHiddenResponses, SetCrmCompanyNameData, SetCrmCompanyNameErrors, SetCrmCompanyNameResponses, SetCrmContactNameData, SetCrmContactNameErrors, SetCrmContactNameResponses, SetDocumentTeamShareData, SetDocumentTeamShareErrors, SetDocumentTeamShareResponses, SetEmailFollowupData, SetEmailFollowupErrors, SetEmailFollowupResponses, SetEmailSyncData, SetEmailSyncErrors, SetEmailSyncResponses, SetSkillDescriptionData, SetSkillDescriptionErrors, SetSkillDescriptionResponses, ShareCrmPipelineData, ShareCrmPipelineResponses, ShareDatabaseAwarenessData, ShareDatabaseAwarenessErrors, ShareDatabaseAwarenessResponses, SimpleSaveData, SimpleSaveErrors, SimpleSaveResponses, StreamEventsData, StreamEventsErrors, StreamEventsResponse, StreamEventsResponses, SubmitFormResponseData, SubmitFormResponseErrors, SubmitFormResponseResponses, TaskSimilaritySearchHandlerData, TaskSimilaritySearchHandlerErrors, TaskSimilaritySearchHandlerResponses, ToggleShareWithTeamData, ToggleShareWithTeamErrors, ToggleShareWithTeamResponses, TranscribeDictationData, TranscribeDictationErrors, TranscribeDictationResponses, TrashCrmPipelineData, TrashCrmPipelineResponses, UnblockCrmDomainData, UnblockCrmDomainErrors, UnblockCrmDomainResponses, UndoDatabaseChangeData, UndoDatabaseChangeErrors, UndoDatabaseChangeResponses, UpdateAgentData, UpdateAgentErrors, UpdateAgentResponses, UpdateCrmPipelinePermissionsData, UpdateCrmPipelinePermissionsResponses, UpdateDatabasePermissionsData, UpdateDatabasePermissionsErrors, UpdateDatabasePermissionsResponses, UpdateFormData, UpdateFormErrors, UpdateFormPermissionsData, UpdateFormPermissionsErrors, UpdateFormPermissionsResponses, UpdateFormResponses, UpdateInitiativeData, UpdateInitiativeErrors, UpdateInitiativeResponses, UploadExtractFolderHandlerData, UploadExtractFolderHandlerErrors, UploadExtractFolderHandlerResponses, UploadFolderHandlerData, UploadFolderHandlerErrors, UploadFolderHandlerResponses, UpsertHistoryHandlerData, UpsertHistoryHandlerErrors, UpsertHistoryHandlerResponses, UpsertUserDocumentViewLocationData, UpsertUserDocumentViewLocationErrors, UpsertUserDocumentViewLocationResponses, ValidateDocumentPermissionsTokenData, ValidateDocumentPermissionsTokenErrors, ValidateDocumentPermissionsTokenResponses, ValidateWebhookData, ValidateWebhookErrors, ValidateWebhookResponses, WhatsappAccountData, WhatsappAccountResponses, WhatsappCancelPairingData, WhatsappCancelPairingResponses, WhatsappChatsData, WhatsappChatsResponses, WhatsappConnectData, WhatsappConnectResponses, WhatsappDisconnectData, WhatsappDisconnectResponses, WhatsappImportHistoryData, WhatsappImportHistoryResponses, WhatsappLookupData, WhatsappLookupResponses, WhatsappPairingData, WhatsappPairingResponses, WhatsappPasskeyData, WhatsappPasskeyResponses, WhatsappStartLookupData, WhatsappStartLookupResponses } from './types.gen';export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {/**@@ -1736,8 +1736,8 @@ export class Sdk extends HeyApiClient {}/**- * Creates a skill document with initialized markdown content in one- * backend-owned lifecycle. Skills are markdown documents containing+ * Creates a skill document with initialized markdown content and its+ * routing description in one backend-owned lifecycle. Skills are markdown documents containing* instructions that AI reads and follows when the skill is referenced in an* AI input.*/@@ -2080,6 +2080,29 @@ export class Sdk extends HeyApiClient {return (options.client ?? this.client).put<SimpleSaveResponses, SimpleSaveErrors, ThrowOnError>({ url: '/documents/{document_id}/simple_save', ...options });}+ /**+ * Gets when to use a skill. `description` is absent for a skill created+ * before descriptions existed.+ */+ public getSkillDescription<ThrowOnError extends boolean = false>(options: Options<GetSkillDescriptionData, ThrowOnError>): RequestResult<GetSkillDescriptionResponses, GetSkillDescriptionErrors, ThrowOnError> {+ return (options.client ?? this.client).get<GetSkillDescriptionResponses, GetSkillDescriptionErrors, ThrowOnError>({ url: '/documents/{document_id}/skill_description', ...options });+ }++ /**+ * Sets when to use a skill: one line starting "Use when", at most 300+ * characters. Agents choose skills for a request by it.+ */+ public setSkillDescription<ThrowOnError extends boolean = false>(options: Options<SetSkillDescriptionData, ThrowOnError>): RequestResult<SetSkillDescriptionResponses, SetSkillDescriptionErrors, ThrowOnError> {+ return (options.client ?? this.client).put<SetSkillDescriptionResponses, SetSkillDescriptionErrors, ThrowOnError>({+ url: '/documents/{document_id}/skill_description',+ ...options,+ headers: {+ 'Content-Type': 'application/json',+ ...options.headers+ }+ });+ }+/*** Gets the team-share state of a document. The team is resolved from the* document owner's team membership; `teamId` is omitted when the owner doesdiff --git a/packages/sdk/generated/storage/types.gen.ts b/packages/sdk/generated/storage/types.gen.tsindex f252deaafb..dd0f7b478d 100644--- a/packages/sdk/generated/storage/types.gen.ts+++ b/packages/sdk/generated/storage/types.gen.ts@@ -4516,6 +4516,12 @@ export type CreateProjectResponse = {* AI input.*/export type CreateSkillRequest = {+ /**+ * When to use the skill, in one line starting "Use when", e.g. "Use when+ * drafting release notes; not changelog entries". Agents choose skills+ * for a request by it.+ */+ description: string;/*** Markdown source text. Defaults to an empty skill document.*/@@ -13024,6 +13030,17 @@ export type SetPropertyValue = {urls: Array<string>;};+/**+ * Request body for setting a skill's routing description.+ */+export type SetSkillDescriptionRequest = {+ /**+ * When to use the skill, in one line starting "Use when", at most 300+ * characters.+ */+ description: string;+};+/*** SHA-256 encoded as exactly 64 lowercase hexadecimal characters.*/@@ -13123,6 +13140,17 @@ export type SimpleMention = {entity_type: string;};+/**+ * A skill's routing description.+ */+export type SkillDescriptionBody = {+ /**+ * When to use the skill, in one line starting "Use when". Absent for a+ * skill created before descriptions existed.+ */+ description?: string | null;+};+/*** A cell an undo left alone, because someone changed it after the change* being undone.@@ -21162,6 +21190,9 @@ export type CreateSkillHandlerData = {};export type CreateSkillHandlerErrors = {+ /**+ * The description is blank, longer than one line or 300 characters, or does not start "Use when"+ */400: ErrorResponse;401: ErrorResponse;500: ErrorResponse;@@ -22031,6 +22062,62 @@ export type SimpleSaveResponses = {export type SimpleSaveResponse = SimpleSaveResponses[keyof SimpleSaveResponses];+export type GetSkillDescriptionData = {+ body?: never;+ path: {+ /**+ * Skill document ID+ */+ document_id: string;+ };+ query?: never;+ url: '/documents/{document_id}/skill_description';+};++export type GetSkillDescriptionErrors = {+ 401: ErrorResponse;+ 404: ErrorResponse;+ 500: ErrorResponse;+};++export type GetSkillDescriptionError = GetSkillDescriptionErrors[keyof GetSkillDescriptionErrors];++export type GetSkillDescriptionResponses = {+ 200: SkillDescriptionBody;+};++export type GetSkillDescriptionResponse = GetSkillDescriptionResponses[keyof GetSkillDescriptionResponses];++export type SetSkillDescriptionData = {+ body: SetSkillDescriptionRequest;+ path: {+ /**+ * Skill document ID+ */+ document_id: string;+ };+ query?: never;+ url: '/documents/{document_id}/skill_description';+};++export type SetSkillDescriptionErrors = {+ /**+ * The document is not a skill, or the description is invalid+ */+ 400: ErrorResponse;+ 401: ErrorResponse;+ 404: ErrorResponse;+ 500: ErrorResponse;+};++export type SetSkillDescriptionError = SetSkillDescriptionErrors[keyof SetSkillDescriptionErrors];++export type SetSkillDescriptionResponses = {+ 200: SkillDescriptionBody;+};++export type SetSkillDescriptionResponse = SetSkillDescriptionResponses[keyof SetSkillDescriptionResponses];+export type GetDocumentTeamShareData = {body?: never;path: {diff --git a/packages/sdk/specs/storage.json b/packages/sdk/specs/storage.jsonindex 80485a4a3b..f358bb5b48 100644--- a/packages/sdk/specs/storage.json+++ b/packages/sdk/specs/storage.json@@ -9742,7 +9742,7 @@"/documents/create_skill": {"post": {"tags": ["document"],- "summary": "Creates a skill document with initialized markdown content in one\nbackend-owned lifecycle. Skills are markdown documents containing\ninstructions that AI reads and follows when the skill is referenced in an\nAI input.",+ "summary": "Creates a skill document with initialized markdown content and its\nrouting description in one backend-owned lifecycle. Skills are markdown documents containing\ninstructions that AI reads and follows when the skill is referenced in an\nAI input.","operationId": "create_skill_handler","requestBody": {"content": {@@ -9774,7 +9774,7 @@}},"400": {- "description": "",+ "description": "The description is blank, longer than one line or 300 characters, or does not start \"Use when\"","content": {"application/json": {"schema": {@@ -11822,6 +11822,144 @@}}},+ "/documents/{document_id}/skill_description": {+ "get": {+ "tags": ["document"],+ "summary": "Gets when to use a skill. `description` is absent for a skill created\nbefore descriptions existed.",+ "operationId": "get_skill_description",+ "parameters": [+ {+ "name": "document_id",+ "in": "path",+ "description": "Skill document ID",+ "required": true,+ "schema": {+ "type": "string"+ }+ }+ ],+ "responses": {+ "200": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/SkillDescriptionBody"+ }+ }+ }+ },+ "401": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "404": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "500": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ }+ }+ },+ "put": {+ "tags": ["document"],+ "summary": "Sets when to use a skill: one line starting \"Use when\", at most 300\ncharacters. Agents choose skills for a request by it.",+ "operationId": "set_skill_description",+ "parameters": [+ {+ "name": "document_id",+ "in": "path",+ "description": "Skill document ID",+ "required": true,+ "schema": {+ "type": "string"+ }+ }+ ],+ "requestBody": {+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/SetSkillDescriptionRequest"+ }+ }+ },+ "required": true+ },+ "responses": {+ "200": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/SkillDescriptionBody"+ }+ }+ }+ },+ "400": {+ "description": "The document is not a skill, or the description is invalid",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "401": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "404": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ },+ "500": {+ "description": "",+ "content": {+ "application/json": {+ "schema": {+ "$ref": "#/components/schemas/ErrorResponse"+ }+ }+ }+ }+ }+ }+ },"/documents/{document_id}/team_share": {"get": {"tags": ["document"],@@ -26792,8 +26930,12 @@"CreateSkillRequest": {"type": "object","description": "Request body for creating a skill — a markdown document containing\ninstructions that AI reads and follows when the skill is referenced in an\nAI input.",- "required": ["skillName"],+ "required": ["skillName", "description"],"properties": {+ "description": {+ "type": "string",+ "description": "When to use the skill, in one line starting \"Use when\", e.g. \"Use when\ndrafting release notes; not changelog entries\". Agents choose skills\nfor a request by it."+ },"markdown": {"type": ["string", "null"],"description": "Markdown source text. Defaults to an empty skill document."@@ -40679,6 +40821,17 @@],"description": "Type-safe enum for setting entity property values - provides compile-time validation."},+ "SetSkillDescriptionRequest": {+ "type": "object",+ "description": "Request body for setting a skill's routing description.",+ "required": ["description"],+ "properties": {+ "description": {+ "type": "string",+ "description": "When to use the skill, in one line starting \"Use when\", at most 300\ncharacters."+ }+ }+ },"Sha256Digest": {"type": "string","description": "SHA-256 encoded as exactly 64 lowercase hexadecimal characters."@@ -40831,6 +40984,16 @@}}},+ "SkillDescriptionBody": {+ "type": "object",+ "description": "A skill's routing description.",+ "properties": {+ "description": {+ "type": ["string", "null"],+ "description": "When to use the skill, in one line starting \"Use when\". Absent for a\nskill created before descriptions existed."+ }+ }+ },"SkippedCell": {"type": "object","description": "A cell an undo left alone, because someone changed it after the change\nbeing undone.",diff --git a/packages/sdk/src/entities/documents/document.ts b/packages/sdk/src/entities/documents/document.tsindex 21e403f95f..86775e6cfa 100644--- a/packages/sdk/src/entities/documents/document.ts+++ b/packages/sdk/src/entities/documents/document.ts@@ -214,16 +214,23 @@ export class Document/*** Create a skill: a markdown document containing instructions that AI reads- * and follows when the skill is referenced in an AI input.+ * and follows when the skill is referenced in an AI input, or when a request+ * matches its `description`.*/static async createSkill(client: MacroClient,- opts: { name: string; markdown?: string; project?: Project },+ opts: {+ name: string;+ description: string;+ markdown?: string;+ project?: Project;+ },): Promise<Document> {const { documentId } = unwrap(await client.storage.createSkillHandler({body: {skillName: opts.name,+ description: opts.description,markdown: opts.markdown ?? null,projectId: opts.project?.id ?? null,},@@ -543,6 +550,33 @@ export class Document);}+ /**+ * When to use this skill: one line starting "Use when". `undefined` for a+ * skill created before descriptions existed.+ */+ async skillDescription(): Promise<string | undefined> {+ const { description } = unwrap(+ await this.client.storage.getSkillDescription({+ path: { document_id: this.id },+ }),+ );+ return description ?? undefined;+ }++ /**+ * Set when to use this skill: one line starting "Use when", at most 300+ * characters, e.g. "Use when drafting release notes; not changelogs".+ * Agents load the skill for requests it describes.+ */+ async setSkillDescription(description: string): Promise<void> {+ await this.mutate((c) =>+ c.storage.setSkillDescription({+ path: { document_id: this.id },+ body: { description },+ }),+ );+ }+/** GitHub pull requests associated with the document. */async githubPullRequests(): Promise<GithubPullRequest[]> {const { pullRequests } = unwrap(diff --git a/packages/sdk/src/entities/documents/namespace.ts b/packages/sdk/src/entities/documents/namespace.tsindex bd9b0e5f65..5beae20840 100644--- a/packages/sdk/src/entities/documents/namespace.ts+++ b/packages/sdk/src/entities/documents/namespace.ts@@ -157,9 +157,13 @@ export class DocumentNamespace {* Read a skill the request names before doing the task, and follow it for* that request only. `systemSkills()` lists the built-in skills, whose* instructions have no document; read those with the ReadSkill tool.+ *+ * `description` says when to use the skill, in one line starting "Use when"+ * (at most 300 characters); agents load the skill for requests it describes.*/createSkill(opts: {name: string;+ description: string;markdown?: string;project?: Project;}): Promise<Document> {diff --git a/services/agent_harness_service/src/main.rs b/services/agent_harness_service/src/main.rsindex d8f30b67aa..27f6dda198 100644--- a/services/agent_harness_service/src/main.rs+++ b/services/agent_harness_service/src/main.rs@@ -829,12 +829,17 @@ async fn run() -> anyhow::Result<()> {if let Some(selector) = &code_mode_selector {inmem_engine = inmem_engine.with_tool_mode(Arc::clone(selector));}- // `auto-skills` decides, per user, whether code-mode turns load the SDK- // areas a request needs instead of carrying every area's guidance.+ // `auto-skills` decides, per user, whether a turn loads the user's skills+ // its request needs, and whether code-mode turns load the SDK areas a+ // request needs instead of carrying every area's guidance.if let Some(flags) = &feature_flags {- inmem_engine = inmem_engine.with_entity_routing(Arc::new(- agent_inmem::domain::entity_routing::FlaggedEntityRouting::new(flags.clone()),- ));+ inmem_engine = inmem_engine+ .with_skill_routing(Arc::new(+ agent_inmem::domain::skill_routing::FlaggedSkillRouting::new(flags.clone()),+ ))+ .with_entity_routing(Arc::new(+ agent_inmem::domain::entity_routing::FlaggedEntityRouting::new(flags.clone()),+ ));}let inmem_model_engine: Arc<dyn TurnEngine> = Arc::new(inmem_engine);// Normalize uploaded images before any provider sees them. In addition todiff --git a/services/document_storage_service/src/api/swagger.rs b/services/document_storage_service/src/api/swagger.rsindex 5d6c6c0f1f..065b9b1108 100644--- a/services/document_storage_service/src/api/swagger.rs+++ b/services/document_storage_service/src/api/swagger.rs@@ -271,6 +271,8 @@ use utoipa::OpenApi;documents_hex::inbound::axum_router::system_skills::get_system_skills_handler,documents_hex::inbound::axum_router::team_share::get_team_share_handler,documents_hex::inbound::axum_router::team_share::set_team_share_handler,+ documents_hex::inbound::axum_router::skill_description::get_skill_description_handler,+ documents_hex::inbound::axum_router::skill_description::set_skill_description_handler,// instructionsinstructions::create_instructions::create_instructions_handler,@@ -624,6 +626,8 @@ use utoipa::OpenApi;documents_hex::domain::models::CreateSkillResponse,documents_hex::domain::models::DocumentTeamShareResponse,documents_hex::domain::models::SetDocumentTeamShareRequest,+ documents_hex::domain::models::SetSkillDescriptionRequest,+ documents_hex::domain::models::SkillDescriptionBody,documents_hex::domain::models::PropertyInput,models_properties::api::requests::SetPropertyValue,models_properties::shared::EntityReference,