provider 2506 operations 141 docs pages

@utdk/posthog

PostHog API

Generated UTDK provider client for PostHog API. Generated UTDK provider types and OpenAPI-backed client for https://us.posthog.com/api/schema/.

Import sample

import posthog from "@utdk/posthog"

Factory sample

import { createPosthogClient } from "@utdk/posthog"

Provider path: posthog
Source API title: PostHog API
Version: 1.0.0
Generated: Jul 12, 2026, 9:26 PM
Homepage: Open site
API spec: View spec

Agent Platform

Optional generated docs page for @utdk/posthog.

Agent Platform

Operations

`posthog.agentApplicationsList`

HTTP: GET /api/projects/{project_id}/agent_applications/
What it does: Agent applications — the deployable unit of the platform.

URLs: GET /api/projects//agent_applications/ list POST /api/projects//agent_applications/ create GET /api/projects//agent_applications/<id|slug>/ retrieve PATCH /api/projects//agent_applications/<id|slug>/ update DELETE /api/projects//agent_applications/<id|slug>/ archive POST /api/projects//agent_applications/<id|slug>/set_env/ bulk replace env GET /api/projects//agent_applications/<id|slug>/env_keys/ list set keys GET /api/projects//agent_applications/<id|slug>/env_keys// is one key set? PUT /api/projects//agent_applications/<id|slug>/env_keys// set one key DELETE /api/projects//agent_applications/<id|slug>/env_keys// clear one key

OpenAPI operationId: agent_applications_list
Path params: None
Query params: limit, offset
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { count: number; next?: string | null; previous?: string | null; results: ({ id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at:...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsListInput = Parameters<typeof posthog.agentApplicationsList> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsListOutput = Awaited<ReturnType<typeof posthog.agentApplicationsList>>;

const result: AgentApplicationsListOutput = await posthog.agentApplicationsList();

// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at:...

`posthog.agentApplicationsCreate`

HTTP: POST /api/projects/{project_id}/agent_applications/
What it does: Agent applications — the deployable unit of the platform.

OpenAPI operationId: agent_applications_create
Path params: None
Query params: None
Response codes: 201
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
OpenAPI response codes: 201

import posthog from "@utdk/posthog";

type AgentApplicationsCreateInput = Parameters<typeof posthog.agentApplicationsCreate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsCreate>>;

const result: AgentApplicationsCreateOutput = await posthog.agentApplicationsCreate();

// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...

`posthog.agentMemoryListFiles`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/memory/files/
What it does: List memory file headers under the agent's prefix. Headers only — no bodies.
OpenAPI operationId: agent_memory_list_files
Path params: application_id
Query params: prefix
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { count: number; entries: ({ path: string; description: string; tags: (string)[]; created_at: string | null; updated_at: string | null })[] }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentMemoryListFilesInput = Parameters<typeof posthog.agentMemoryListFiles> extends [infer T, ...unknown[]] ? T : undefined;
type AgentMemoryListFilesOutput = Awaited<ReturnType<typeof posthog.agentMemoryListFiles>>;

const result: AgentMemoryListFilesOutput = await posthog.agentMemoryListFiles();

// Result shape (from schema): { count: number; entries: ({ path: string; description: string; tags: (string)[]; created_at: string | null; updated_at: string | null })[] }

`posthog.agentMemoryCreateFile`

HTTP: POST /api/projects/{project_id}/agent_applications/{application_id}/memory/files/
What it does: Create a memory file. Fails if the path already exists — use the update endpoint to overwrite.
OpenAPI operationId: agent_memory_create_file
Path params: application_id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { content: string }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentMemoryCreateFileInput = Parameters<typeof posthog.agentMemoryCreateFile> extends [infer T, ...unknown[]] ? T : undefined;
type AgentMemoryCreateFileOutput = Awaited<ReturnType<typeof posthog.agentMemoryCreateFile>>;

const result: AgentMemoryCreateFileOutput = await posthog.agentMemoryCreateFile();

// Result shape (from schema): { content: string }

`posthog.agentMemoryDeleteFile`

HTTP: DELETE /api/projects/{project_id}/agent_applications/{application_id}/memory/files/by_path/
What it does: Hard-delete a memory file. Activity log captures the action against the agent.
OpenAPI operationId: agent_memory_delete_file
Path params: application_id
Query params: path
Response codes: 204
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: unknown
OpenAPI response codes: 204

import posthog from "@utdk/posthog";

type AgentMemoryDeleteFileInput = Parameters<typeof posthog.agentMemoryDeleteFile> extends [infer T, ...unknown[]] ? T : undefined;
type AgentMemoryDeleteFileOutput = Awaited<ReturnType<typeof posthog.agentMemoryDeleteFile>>;

const result: AgentMemoryDeleteFileOutput = await posthog.agentMemoryDeleteFile();

// Result shape (from schema): unknown

`posthog.agentMemoryGetFile`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/memory/files/by_path/
What it does: Read one memory file in full (frontmatter + markdown body).
OpenAPI operationId: agent_memory_get_file
Path params: application_id
Query params: path
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { content: string }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentMemoryGetFileInput = Parameters<typeof posthog.agentMemoryGetFile> extends [infer T, ...unknown[]] ? T : undefined;
type AgentMemoryGetFileOutput = Awaited<ReturnType<typeof posthog.agentMemoryGetFile>>;

const result: AgentMemoryGetFileOutput = await posthog.agentMemoryGetFile();

// Result shape (from schema): { content: string }

`posthog.agentMemoryUpdateFile`

HTTP: PATCH /api/projects/{project_id}/agent_applications/{application_id}/memory/files/by_path/
What it does: Update a memory file. Any field omitted is preserved from the existing file.
OpenAPI operationId: agent_memory_update_file
Path params: application_id
Query params: path
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { content: string }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentMemoryUpdateFileInput = Parameters<typeof posthog.agentMemoryUpdateFile> extends [infer T, ...unknown[]] ? T : undefined;
type AgentMemoryUpdateFileOutput = Awaited<ReturnType<typeof posthog.agentMemoryUpdateFile>>;

const result: AgentMemoryUpdateFileOutput = await posthog.agentMemoryUpdateFile();

// Result shape (from schema): { content: string }

`posthog.agentMemorySearch`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/memory/search/
What it does: BM25 search across the agent's memory files. Ranks by description+tags+path+body with field weighting.
OpenAPI operationId: agent_memory_search
Path params: application_id
Query params: limit, prefix, q
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { cue: string; count: number; results: ({ path: string; description: string; tags: (string)[]; score: number; snippet: string | null })[] }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentMemorySearchInput = Parameters<typeof posthog.agentMemorySearch> extends [infer T, ...unknown[]] ? T : undefined;
type AgentMemorySearchOutput = Awaited<ReturnType<typeof posthog.agentMemorySearch>>;

const result: AgentMemorySearchOutput = await posthog.agentMemorySearch();

// Result shape (from schema): { cue: string; count: number; results: ({ path: string; description: string; tags: (string)[]; score: number; snippet: string | null })[] }

`posthog.agentMemoryListTables`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/memory/tables/
What it does: List the agent's tabular-reference tables (the @posthog/table-* JSONL tables): name + byte size.
OpenAPI operationId: agent_memory_list_tables
Path params: application_id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { count: number; tables: ({ name: string; size: number })[] }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentMemoryListTablesInput = Parameters<typeof posthog.agentMemoryListTables> extends [infer T, ...unknown[]] ? T : undefined;
type AgentMemoryListTablesOutput = Awaited<ReturnType<typeof posthog.agentMemoryListTables>>;

const result: AgentMemoryListTablesOutput = await posthog.agentMemoryListTables();

// Result shape (from schema): { count: number; tables: ({ name: string; size: number })[] }

`posthog.agentMemoryReadTable`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/memory/tables/{name}/
What it does: Read rows from one tabular-reference table (capped via ?limit).
OpenAPI operationId: agent_memory_read_table
Path params: application_id, name
Query params: limit
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { name: string; total: number; returned: number; limit: number; rows: ({ [key: string]: unknown })[] }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentMemoryReadTableInput = Parameters<typeof posthog.agentMemoryReadTable> extends [infer T, ...unknown[]] ? T : undefined;
type AgentMemoryReadTableOutput = Awaited<ReturnType<typeof posthog.agentMemoryReadTable>>;

const result: AgentMemoryReadTableOutput = await posthog.agentMemoryReadTable();

// Result shape (from schema): { name: string; total: number; returned: number; limit: number; rows: ({ [key: string]: unknown })[] }

`posthog.agentMemoryTree`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/memory/tree/
What it does: Pre-aggregated folder tree of memory files. Saves the frontend re-derivation work.
OpenAPI operationId: agent_memory_tree
Path params: application_id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { root: { [key: string]: unknown } }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentMemoryTreeInput = Parameters<typeof posthog.agentMemoryTree> extends [infer T, ...unknown[]] ? T : undefined;
type AgentMemoryTreeOutput = Awaited<ReturnType<typeof posthog.agentMemoryTree>>;

const result: AgentMemoryTreeOutput = await posthog.agentMemoryTree();

// Result shape (from schema): { root: { [key: string]: unknown } }

`posthog.agentApplicationsRevisionsList`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/
What it does: Revisions of an agent. Created in draft, promoted through ready → live once the bundle has been uploaded + frozen.

URLs (nested under an application):

Model CRUD:
    GET   .../revisions/                       list
    POST  .../revisions/                       create draft
    GET   .../revisions/<id>/                  retrieve
    PATCH .../revisions/<id>/                  update spec (draft only)

Lifecycle:
    POST  .../revisions/<id>/promote/          ready → live
    POST  .../revisions/<id>/archive/          → archived
    POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
    POST  .../revisions/<id>/clone_from/       copy bundle from another rev
    POST  .../revisions/new_draft/             create draft + clone_from atomically

Bundle authoring (proxied to the janitor):
    GET    .../revisions/<id>/manifest/        list paths + sha256
    GET    .../revisions/<id>/file/?path=…     read one file
    PUT    .../revisions/<id>/file/?path=…     write one file (draft)
    DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
    GET    .../revisions/<id>/bundle/          bulk pull all files
    PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)

OpenAPI operationId: agent_applications_revisions_list
Path params: application_id
Query params: limit, offset
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { count: number; next?: string | null; previous?: string | null; results: ({ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsListInput = Parameters<typeof posthog.agentApplicationsRevisionsList> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsListOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsList>>;

const result: AgentApplicationsRevisionsListOutput = await posthog.agentApplicationsRevisionsList();

// Result shape (from schema): { count: number; next?: string | null; previous?: string | null; results: ({ id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_...

`posthog.agentApplicationsRevisionsCreate`

HTTP: POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/
What it does: Revisions of an agent. Created in draft, promoted through ready → live once the bundle has been uploaded + frozen.

URLs (nested under an application):

Model CRUD:
    GET   .../revisions/                       list
    POST  .../revisions/                       create draft
    GET   .../revisions/<id>/                  retrieve
    PATCH .../revisions/<id>/                  update spec (draft only)

Lifecycle:
    POST  .../revisions/<id>/promote/          ready → live
    POST  .../revisions/<id>/archive/          → archived
    POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
    POST  .../revisions/<id>/clone_from/       copy bundle from another rev
    POST  .../revisions/new_draft/             create draft + clone_from atomically

Bundle authoring (proxied to the janitor):
    GET    .../revisions/<id>/manifest/        list paths + sha256
    GET    .../revisions/<id>/file/?path=…     read one file
    PUT    .../revisions/<id>/file/?path=…     write one file (draft)
    DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
    GET    .../revisions/<id>/bundle/          bulk pull all files
    PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)

OpenAPI operationId: agent_applications_revisions_create
Path params: application_id
Query params: None
Response codes: 201
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 201

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsCreate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsCreate>>;

const result: AgentApplicationsRevisionsCreateOutput = await posthog.agentApplicationsRevisionsCreate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsDestroy`

HTTP: DELETE /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/
What it does: Revisions of an agent. Created in draft, promoted through ready → live once the bundle has been uploaded + frozen.

URLs (nested under an application):

Model CRUD:
    GET   .../revisions/                       list
    POST  .../revisions/                       create draft
    GET   .../revisions/<id>/                  retrieve
    PATCH .../revisions/<id>/                  update spec (draft only)

Lifecycle:
    POST  .../revisions/<id>/promote/          ready → live
    POST  .../revisions/<id>/archive/          → archived
    POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
    POST  .../revisions/<id>/clone_from/       copy bundle from another rev
    POST  .../revisions/new_draft/             create draft + clone_from atomically

Bundle authoring (proxied to the janitor):
    GET    .../revisions/<id>/manifest/        list paths + sha256
    GET    .../revisions/<id>/file/?path=…     read one file
    PUT    .../revisions/<id>/file/?path=…     write one file (draft)
    DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
    GET    .../revisions/<id>/bundle/          bulk pull all files
    PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)

OpenAPI operationId: agent_applications_revisions_destroy
Path params: application_id, id
Query params: None
Response codes: 204
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: unknown
OpenAPI response codes: 204

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsDestroyInput = Parameters<typeof posthog.agentApplicationsRevisionsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsDestroyOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsDestroy>>;

const result: AgentApplicationsRevisionsDestroyOutput = await posthog.agentApplicationsRevisionsDestroy();

// Result shape (from schema): unknown

`posthog.agentApplicationsRevisionsRetrieve`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/
What it does: Revisions of an agent. Created in draft, promoted through ready → live once the bundle has been uploaded + frozen.

URLs (nested under an application):

Model CRUD:
    GET   .../revisions/                       list
    POST  .../revisions/                       create draft
    GET   .../revisions/<id>/                  retrieve
    PATCH .../revisions/<id>/                  update spec (draft only)

Lifecycle:
    POST  .../revisions/<id>/promote/          ready → live
    POST  .../revisions/<id>/archive/          → archived
    POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
    POST  .../revisions/<id>/clone_from/       copy bundle from another rev
    POST  .../revisions/new_draft/             create draft + clone_from atomically

Bundle authoring (proxied to the janitor):
    GET    .../revisions/<id>/manifest/        list paths + sha256
    GET    .../revisions/<id>/file/?path=…     read one file
    PUT    .../revisions/<id>/file/?path=…     write one file (draft)
    DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
    GET    .../revisions/<id>/bundle/          bulk pull all files
    PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)

OpenAPI operationId: agent_applications_revisions_retrieve
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsRetrieveInput = Parameters<typeof posthog.agentApplicationsRevisionsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsRetrieveOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsRetrieve>>;

const result: AgentApplicationsRevisionsRetrieveOutput = await posthog.agentApplicationsRevisionsRetrieve();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsPartialUpdate`

HTTP: PATCH /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/
What it does: Revisions of an agent. Created in draft, promoted through ready → live once the bundle has been uploaded + frozen.

URLs (nested under an application):

Model CRUD:
    GET   .../revisions/                       list
    POST  .../revisions/                       create draft
    GET   .../revisions/<id>/                  retrieve
    PATCH .../revisions/<id>/                  update spec (draft only)

Lifecycle:
    POST  .../revisions/<id>/promote/          ready → live
    POST  .../revisions/<id>/archive/          → archived
    POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
    POST  .../revisions/<id>/clone_from/       copy bundle from another rev
    POST  .../revisions/new_draft/             create draft + clone_from atomically

Bundle authoring (proxied to the janitor):
    GET    .../revisions/<id>/manifest/        list paths + sha256
    GET    .../revisions/<id>/file/?path=…     read one file
    PUT    .../revisions/<id>/file/?path=…     write one file (draft)
    DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
    GET    .../revisions/<id>/bundle/          bulk pull all files
    PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)

OpenAPI operationId: agent_applications_revisions_partial_update
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsPartialUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsPartialUpdate>>;

const result: AgentApplicationsRevisionsPartialUpdateOutput = await posthog.agentApplicationsRevisionsPartialUpdate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsUpdate`

HTTP: PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/
What it does: Spec edits are only allowed while state='draft'. Once promoted to ready/live the spec is frozen — change requires a new revision.
OpenAPI operationId: agent_applications_revisions_update
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsUpdate>>;

const result: AgentApplicationsRevisionsUpdateOutput = await posthog.agentApplicationsRevisionsUpdate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsAgentMdUpdate`

HTTP: PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/agent_md/
What it does: Revisions of an agent. Created in draft, promoted through ready → live once the bundle has been uploaded + frozen.

URLs (nested under an application):

Model CRUD:
    GET   .../revisions/                       list
    POST  .../revisions/                       create draft
    GET   .../revisions/<id>/                  retrieve
    PATCH .../revisions/<id>/                  update spec (draft only)

Lifecycle:
    POST  .../revisions/<id>/promote/          ready → live
    POST  .../revisions/<id>/archive/          → archived
    POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
    POST  .../revisions/<id>/clone_from/       copy bundle from another rev
    POST  .../revisions/new_draft/             create draft + clone_from atomically

Bundle authoring (proxied to the janitor):
    GET    .../revisions/<id>/manifest/        list paths + sha256
    GET    .../revisions/<id>/file/?path=…     read one file
    PUT    .../revisions/<id>/file/?path=…     write one file (draft)
    DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
    GET    .../revisions/<id>/bundle/          bulk pull all files
    PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)

OpenAPI operationId: agent_applications_revisions_agent_md_update
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsAgentMdUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsAgentMdUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsAgentMdUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsAgentMdUpdate>>;

const result: AgentApplicationsRevisionsAgentMdUpdateOutput = await posthog.agentApplicationsRevisionsAgentMdUpdate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsArchiveCreate`

HTTP: POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/archive/
What it does: Mark a revision archived. If it was the live one, clear the application's live_revision pointer (the app effectively has no deployable version until another revision is promoted).
OpenAPI operationId: agent_applications_revisions_archive_create
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsArchiveCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsArchiveCreate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsArchiveCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsArchiveCreate>>;

const result: AgentApplicationsRevisionsArchiveCreateOutput = await posthog.agentApplicationsRevisionsArchiveCreate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsBundleRetrieve`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/bundle/
What it does: Read the full typed bundle: { agent_md, skills, tools, spec }.
OpenAPI operationId: agent_applications_revisions_bundle_retrieve
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsBundleRetrieveInput = Parameters<typeof posthog.agentApplicationsRevisionsBundleRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsBundleRetrieveOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsBundleRetrieve>>;

const result: AgentApplicationsRevisionsBundleRetrieveOutput = await posthog.agentApplicationsRevisionsBundleRetrieve();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsBundleUpdate`

HTTP: PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/bundle/
What it does: Full-replace the typed bundle. Anything not in the payload is deleted. Tool sources are AST-checked + esbuild-compiled by the janitor before any S3 writes.
OpenAPI operationId: agent_applications_revisions_bundle_update
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsBundleUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsBundleUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsBundleUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsBundleUpdate>>;

const result: AgentApplicationsRevisionsBundleUpdateOutput = await posthog.agentApplicationsRevisionsBundleUpdate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsBundleFileUpdate`

HTTP: PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/bundle/file/
What it does: Update one .md file on a draft revision.

agent.md writes go to the draft bundle. skills/<id>/SKILL.md writes are store-backed — skills are materialized from the skill store at freeze, so the edit publishes a new version of the referenced store skill and re-pins the draft's skill_refs entry to it. <id> must be a ref alias on this revision; add new skills via bundle/import/ or skill_refs. Tool source / schema editing is out of scope here — use the per-tool endpoints. Returns the updated revision so the caller can refresh in one round-trip.

OpenAPI operationId: agent_applications_revisions_bundle_file_update
Path params: application_id, id
Query params: None
Response codes: 200, 409
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200, 409

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsBundleFileUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsBundleFileUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsBundleFileUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsBundleFileUpdate>>;

const result: AgentApplicationsRevisionsBundleFileUpdateOutput = await posthog.agentApplicationsRevisionsBundleFileUpdate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsBundleImportCreate`

HTTP: POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/bundle/import/
What it does: Bulk-merge a set of .md files into a draft revision.

Sets agent_md on the draft bundle if present. skills[] are store-backed and merge by id: an id already referenced by the draft publishes a new version of its store skill; an unreferenced id attaches the store skill of that name (publishing the payload's body to it), or creates it when no such skill exists — and each ref is (re-)pinned to the published version. Skills not mentioned are left alone, so the import is safe to retry. Draft-only; non-draft revisions return 409 untouched.

OpenAPI operationId: agent_applications_revisions_bundle_import_create
Path params: application_id, id
Query params: None
Response codes: 200, 409
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200, 409

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsBundleImportCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsBundleImportCreate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsBundleImportCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsBundleImportCreate>>;

const result: AgentApplicationsRevisionsBundleImportCreateOutput = await posthog.agentApplicationsRevisionsBundleImportCreate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsCloneFromCreate`

HTTP: POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/clone_from/
What it does: Copy every file from source_revision_id into this revision.
OpenAPI operationId: agent_applications_revisions_clone_from_create
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsCloneFromCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsCloneFromCreate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsCloneFromCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsCloneFromCreate>>;

const result: AgentApplicationsRevisionsCloneFromCreateOutput = await posthog.agentApplicationsRevisionsCloneFromCreate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsCronFireCreate`

HTTP: POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/cron/fire/
What it does: Fire one cron job out-of-band — the same execution path the scheduler walks, but on demand. Authoring UX: the user iterates on a cron prompt by clicking 'Fire now' rather than waiting for the next scheduled firing. Without this, 'did my prompt do the right thing?' is unanswerable until the cron actually fires.

Idempotent via request_id: repeat clicks with the same id resolve to the same session id rather than firing N times.

OpenAPI operationId: agent_applications_revisions_cron_fire_create
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { ok: boolean; session_id: string; fired_at: string; idempotency_key: string; request_id: string }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsCronFireCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsCronFireCreate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsCronFireCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsCronFireCreate>>;

const result: AgentApplicationsRevisionsCronFireCreateOutput = await posthog.agentApplicationsRevisionsCronFireCreate();

// Result shape (from schema): { ok: boolean; session_id: string; fired_at: string; idempotency_key: string; request_id: string }

`posthog.agentRevisionsEnvKeysList`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/env_keys/
What it does: List the names of secrets currently set on this revision.

Returns names only — values stay server-side under EncryptedTextField. Use this to drive the "set / unset" badge next to a declared secret in the editor UI.

OpenAPI operationId: agent_revisions_env_keys_list
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { keys: (string)[] }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentRevisionsEnvKeysListInput = Parameters<typeof posthog.agentRevisionsEnvKeysList> extends [infer T, ...unknown[]] ? T : undefined;
type AgentRevisionsEnvKeysListOutput = Awaited<ReturnType<typeof posthog.agentRevisionsEnvKeysList>>;

const result: AgentRevisionsEnvKeysListOutput = await posthog.agentRevisionsEnvKeysList();

// Result shape (from schema): { keys: (string)[] }

`posthog.agentRevisionsEnvKeysClear`

HTTP: DELETE /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/env_keys/{key}/
What it does: GET / PUT / DELETE one secret by name on this revision.
GET → { key, is_set } (never returns the value).
PUT → upserts { value } into the env block.
DELETE → removes the key. No-op when it wasn't set.

Per-method scope: GET is treated as a write action so the single action name maps to one consistent scope; reading whether a secret is set is restricted to writers in any case.

OpenAPI operationId: agent_revisions_env_keys_clear
Path params: application_id, id, key
Query params: None
Response codes: 204
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: unknown
OpenAPI response codes: 204

import posthog from "@utdk/posthog";

type AgentRevisionsEnvKeysClearInput = Parameters<typeof posthog.agentRevisionsEnvKeysClear> extends [infer T, ...unknown[]] ? T : undefined;
type AgentRevisionsEnvKeysClearOutput = Awaited<ReturnType<typeof posthog.agentRevisionsEnvKeysClear>>;

const result: AgentRevisionsEnvKeysClearOutput = await posthog.agentRevisionsEnvKeysClear();

// Result shape (from schema): unknown

`posthog.agentRevisionsEnvKeysGet`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/env_keys/{key}/
What it does: GET / PUT / DELETE one secret by name on this revision.
GET → { key, is_set } (never returns the value).
PUT → upserts { value } into the env block.
DELETE → removes the key. No-op when it wasn't set.

Per-method scope: GET is treated as a write action so the single action name maps to one consistent scope; reading whether a secret is set is restricted to writers in any case.

OpenAPI operationId: agent_revisions_env_keys_get
Path params: application_id, id, key
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { key: string; is_set: boolean }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentRevisionsEnvKeysGetInput = Parameters<typeof posthog.agentRevisionsEnvKeysGet> extends [infer T, ...unknown[]] ? T : undefined;
type AgentRevisionsEnvKeysGetOutput = Awaited<ReturnType<typeof posthog.agentRevisionsEnvKeysGet>>;

const result: AgentRevisionsEnvKeysGetOutput = await posthog.agentRevisionsEnvKeysGet();

// Result shape (from schema): { key: string; is_set: boolean }

`posthog.agentRevisionsEnvKeysSet`

HTTP: PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/env_keys/{key}/
What it does: GET / PUT / DELETE one secret by name on this revision.
GET → { key, is_set } (never returns the value).
PUT → upserts { value } into the env block.
DELETE → removes the key. No-op when it wasn't set.

Per-method scope: GET is treated as a write action so the single action name maps to one consistent scope; reading whether a secret is set is restricted to writers in any case.

OpenAPI operationId: agent_revisions_env_keys_set
Path params: application_id, id, key
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { key: string; is_set: boolean }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentRevisionsEnvKeysSetInput = Parameters<typeof posthog.agentRevisionsEnvKeysSet> extends [infer T, ...unknown[]] ? T : undefined;
type AgentRevisionsEnvKeysSetOutput = Awaited<ReturnType<typeof posthog.agentRevisionsEnvKeysSet>>;

const result: AgentRevisionsEnvKeysSetOutput = await posthog.agentRevisionsEnvKeysSet();

// Result shape (from schema): { key: string; is_set: boolean }

`posthog.agentApplicationsRevisionsFreezeCreate`

HTTP: POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/freeze/
What it does: Freeze the bundle: draft → ready, stamps sha256 on the row.

Django is a thin proxy here: resolve template refs into the bundle, ask the janitor to seal it (the janitor returns the sha

the spec it derived from the typed resources), then stamp the row. No transaction.atomic() — the janitor's freeze is idempotent (on retry it re-reads the existing .frozen marker + re-derives spec), so a partial failure here is recoverable by re-calling freeze, not by transactional rollback. Holding an atomic block across the janitor HTTP call previously deadlocked the agent_revision row against the janitor's spec write — that's moved off the janitor side as part of the same fix.

OpenAPI operationId: agent_applications_revisions_freeze_create
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsFreezeCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsFreezeCreate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsFreezeCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsFreezeCreate>>;

const result: AgentApplicationsRevisionsFreezeCreateOutput = await posthog.agentApplicationsRevisionsFreezeCreate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsManifestRetrieve`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/manifest/
What it does: List every file in this revision's bundle (path, size, sha256).
OpenAPI operationId: agent_applications_revisions_manifest_retrieve
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsManifestRetrieveInput = Parameters<typeof posthog.agentApplicationsRevisionsManifestRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsManifestRetrieveOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsManifestRetrieve>>;

const result: AgentApplicationsRevisionsManifestRetrieveOutput = await posthog.agentApplicationsRevisionsManifestRetrieve();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsPromoteCreate`

HTTP: POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/promote/
What it does: ready → live. Sets the parent application's live_revision.
OpenAPI operationId: agent_applications_revisions_promote_create
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsPromoteCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsPromoteCreate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsPromoteCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsPromoteCreate>>;

const result: AgentApplicationsRevisionsPromoteCreateOutput = await posthog.agentApplicationsRevisionsPromoteCreate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsSetEnvCreate`

HTTP: POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/set_env/
What it does: Replace this revision's encrypted env block.

The body is { "env": { "<KEY>": "<value>", ... } }. The encrypted text is stored on AgentRevision.encrypted_env; the worker decrypts it at session start via the same Fernet schedule (see agent-shared/src/runtime/encryption.ts).

OpenAPI operationId: agent_applications_revisions_set_env_create
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsSetEnvCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsSetEnvCreate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsSetEnvCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsSetEnvCreate>>;

const result: AgentApplicationsRevisionsSetEnvCreateOutput = await posthog.agentApplicationsRevisionsSetEnvCreate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsSkillRefsUpdate`

HTTP: PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/skill_refs/
What it does: Full-replace the draft's store-skill references. They are resolved and materialized into the bundle at freeze, not here — this only records which skills (and pinned versions) the freeze should pull in.
OpenAPI operationId: agent_applications_revisions_skill_refs_update
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsSkillRefsUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsSkillRefsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsSkillRefsUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsSkillRefsUpdate>>;

const result: AgentApplicationsRevisionsSkillRefsUpdateOutput = await posthog.agentApplicationsRevisionsSkillRefsUpdate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsSlackManifest`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/slack_manifest/
What it does: Build a Slack app manifest for this revision's slack trigger.

Deterministic: the OAuth scopes and bot event subscriptions are derived from the slack trigger config (mention_only / auto_resume_threads / ack_reaction) and the agent's Slack tools, so the manifest already subscribes to exactly the events the config needs. 400 if the revision has no slack trigger.

OpenAPI operationId: agent_applications_revisions_slack_manifest
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { revision_id: string; manifest: unknown; notes: (string)[]; events_url: string | null; interactivity_url: string | null }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsSlackManifestInput = Parameters<typeof posthog.agentApplicationsRevisionsSlackManifest> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsSlackManifestOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsSlackManifest>>;

const result: AgentApplicationsRevisionsSlackManifestOutput = await posthog.agentApplicationsRevisionsSlackManifest();

// Result shape (from schema): { revision_id: string; manifest: unknown; notes: (string)[]; events_url: string | null; interactivity_url: string | null }

`posthog.agentApplicationsRevisionsSpecUpdate`

HTTP: PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/spec/
What it does: Revisions of an agent. Created in draft, promoted through ready → live once the bundle has been uploaded + frozen.

URLs (nested under an application):

Model CRUD:
    GET   .../revisions/                       list
    POST  .../revisions/                       create draft
    GET   .../revisions/<id>/                  retrieve
    PATCH .../revisions/<id>/                  update spec (draft only)

Lifecycle:
    POST  .../revisions/<id>/promote/          ready → live
    POST  .../revisions/<id>/archive/          → archived
    POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
    POST  .../revisions/<id>/clone_from/       copy bundle from another rev
    POST  .../revisions/new_draft/             create draft + clone_from atomically

Bundle authoring (proxied to the janitor):
    GET    .../revisions/<id>/manifest/        list paths + sha256
    GET    .../revisions/<id>/file/?path=…     read one file
    PUT    .../revisions/<id>/file/?path=…     write one file (draft)
    DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
    GET    .../revisions/<id>/bundle/          bulk pull all files
    PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)

OpenAPI operationId: agent_applications_revisions_spec_update
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsSpecUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsSpecUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsSpecUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsSpecUpdate>>;

const result: AgentApplicationsRevisionsSpecUpdateOutput = await posthog.agentApplicationsRevisionsSpecUpdate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsSystemPrompt`

HTTP: GET /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/system_prompt/
What it does: Return the fully-assembled system prompt for this revision.

Authoring tools call this to preview what the model will actually see at session start — the platform framework preamble plus the bundle's agent.md plus the skills index. Useful for debugging author-vs-framework precedence conflicts and verifying spec.framework_prompt.omit overrides took effect.

OpenAPI operationId: agent_applications_revisions_system_prompt
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { revision_id: string; framework_prompt_version: number; system_prompt: string }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsSystemPromptInput = Parameters<typeof posthog.agentApplicationsRevisionsSystemPrompt> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsSystemPromptOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsSystemPrompt>>;

const result: AgentApplicationsRevisionsSystemPromptOutput = await posthog.agentApplicationsRevisionsSystemPrompt();

// Result shape (from schema): { revision_id: string; framework_prompt_version: number; system_prompt: string }

`posthog.agentApplicationsRevisionsToolsDestroy`

HTTP: DELETE /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/tools/{tool_id}/
What it does: Revisions of an agent. Created in draft, promoted through ready → live once the bundle has been uploaded + frozen.

URLs (nested under an application):

Model CRUD:
    GET   .../revisions/                       list
    POST  .../revisions/                       create draft
    GET   .../revisions/<id>/                  retrieve
    PATCH .../revisions/<id>/                  update spec (draft only)

Lifecycle:
    POST  .../revisions/<id>/promote/          ready → live
    POST  .../revisions/<id>/archive/          → archived
    POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
    POST  .../revisions/<id>/clone_from/       copy bundle from another rev
    POST  .../revisions/new_draft/             create draft + clone_from atomically

Bundle authoring (proxied to the janitor):
    GET    .../revisions/<id>/manifest/        list paths + sha256
    GET    .../revisions/<id>/file/?path=…     read one file
    PUT    .../revisions/<id>/file/?path=…     write one file (draft)
    DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
    GET    .../revisions/<id>/bundle/          bulk pull all files
    PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)

OpenAPI operationId: agent_applications_revisions_tools_destroy
Path params: application_id, id, tool_id
Query params: None
Response codes: 204
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: unknown
OpenAPI response codes: 204

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsToolsDestroyInput = Parameters<typeof posthog.agentApplicationsRevisionsToolsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsToolsDestroyOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsToolsDestroy>>;

const result: AgentApplicationsRevisionsToolsDestroyOutput = await posthog.agentApplicationsRevisionsToolsDestroy();

// Result shape (from schema): unknown

`posthog.agentApplicationsRevisionsToolsUpdate`

HTTP: PUT /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/tools/{tool_id}/
What it does: Revisions of an agent. Created in draft, promoted through ready → live once the bundle has been uploaded + frozen.

URLs (nested under an application):

Model CRUD:
    GET   .../revisions/                       list
    POST  .../revisions/                       create draft
    GET   .../revisions/<id>/                  retrieve
    PATCH .../revisions/<id>/                  update spec (draft only)

Lifecycle:
    POST  .../revisions/<id>/promote/          ready → live
    POST  .../revisions/<id>/archive/          → archived
    POST  .../revisions/<id>/freeze/           draft → ready (stamps sha256)
    POST  .../revisions/<id>/clone_from/       copy bundle from another rev
    POST  .../revisions/new_draft/             create draft + clone_from atomically

Bundle authoring (proxied to the janitor):
    GET    .../revisions/<id>/manifest/        list paths + sha256
    GET    .../revisions/<id>/file/?path=…     read one file
    PUT    .../revisions/<id>/file/?path=…     write one file (draft)
    DELETE .../revisions/<id>/file/?path=…     delete one file (draft)
    GET    .../revisions/<id>/bundle/          bulk pull all files
    PUT    .../revisions/<id>/bundle/          bulk push (replace|merge)

OpenAPI operationId: agent_applications_revisions_tools_update
Path params: application_id, id, tool_id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsToolsUpdateInput = Parameters<typeof posthog.agentApplicationsRevisionsToolsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsToolsUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsToolsUpdate>>;

const result: AgentApplicationsRevisionsToolsUpdateOutput = await posthog.agentApplicationsRevisionsToolsUpdate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsRevisionsToolsDryRunCreate`

HTTP: POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/tools/{tool_id}/dry_run/
What it does: Execute one persisted custom tool in a single-shot sandbox.

Authoring loop's "test this tool" button. The tool's source must already be PUT (compiled.js is what runs); this just invokes it with the caller-supplied args and a stubbed ctx. No real secrets leave Django — mock_secrets is a {name → placeholder} map.

OpenAPI operationId: agent_applications_revisions_tools_dry_run_create
Path params: application_id, id, tool_id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { ok: boolean; tool_id: string; result?: unknown; error?: { code: string; message: string }; duration_ms: number }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsToolsDryRunCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsToolsDryRunCreate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsToolsDryRunCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsToolsDryRunCreate>>;

const result: AgentApplicationsRevisionsToolsDryRunCreateOutput = await posthog.agentApplicationsRevisionsToolsDryRunCreate();

// Result shape (from schema): { ok: boolean; tool_id: string; result?: unknown; error?: { code: string; message: string }; duration_ms: number }

`posthog.agentApplicationsRevisionsValidateCreate`

HTTP: POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/{id}/validate/
What it does: Pre-flight checks before freeze + promote: agent.md exists, every native tool id is registered, every custom tool has its compiled.js + schema.json, every skill path exists, every declared secret has a value set in this revision's env block. Returns { ok, errors: [...] }. Works on any revision state.
OpenAPI operationId: agent_applications_revisions_validate_create
Path params: application_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { ok: boolean; revision_id: string; revision_state: string; errors: ({ code: string; message: string; pointer: string })[]; resolved_natives: (string)[] }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsValidateCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsValidateCreate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsValidateCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsValidateCreate>>;

const result: AgentApplicationsRevisionsValidateCreateOutput = await posthog.agentApplicationsRevisionsValidateCreate();

// Result shape (from schema): { ok: boolean; revision_id: string; revision_state: string; errors: ({ code: string; message: string; pointer: string })[]; resolved_natives: (string)[] }

`posthog.agentApplicationsRevisionsNewDraftCreate`

HTTP: POST /api/projects/{project_id}/agent_applications/{application_id}/revisions/new_draft/
What it does: Create a fresh draft revision under application_id and seed it from source_revision_id. Saves the MCP one round-trip vs the explicit create + clone_from sequence.
OpenAPI operationId: agent_applications_revisions_new_draft_create
Path params: application_id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRevisionsNewDraftCreateInput = Parameters<typeof posthog.agentApplicationsRevisionsNewDraftCreate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRevisionsNewDraftCreateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRevisionsNewDraftCreate>>;

const result: AgentApplicationsRevisionsNewDraftCreateOutput = await posthog.agentApplicationsRevisionsNewDraftCreate();

// Result shape (from schema): { id: string; application: string; parent_revision?: string | null; state: "draft" | "ready" | "live" | "archived"; bundle_uri?: string; bundle_sha256: string | null; spec?: unknown; skill_refs: ({ from_template: string...

`posthog.agentApplicationsDestroy`

HTTP: DELETE /api/projects/{project_id}/agent_applications/{id}/
What it does: Agent applications — the deployable unit of the platform.

OpenAPI operationId: agent_applications_destroy
Path params: id
Query params: None
Response codes: 204
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: unknown
OpenAPI response codes: 204

import posthog from "@utdk/posthog";

type AgentApplicationsDestroyInput = Parameters<typeof posthog.agentApplicationsDestroy> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsDestroyOutput = Awaited<ReturnType<typeof posthog.agentApplicationsDestroy>>;

const result: AgentApplicationsDestroyOutput = await posthog.agentApplicationsDestroy();

// Result shape (from schema): unknown

`posthog.agentApplicationsRetrieve`

HTTP: GET /api/projects/{project_id}/agent_applications/{id}/
What it does: Agent applications — the deployable unit of the platform.

OpenAPI operationId: agent_applications_retrieve
Path params: id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsRetrieveInput = Parameters<typeof posthog.agentApplicationsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsRetrieveOutput = Awaited<ReturnType<typeof posthog.agentApplicationsRetrieve>>;

const result: AgentApplicationsRetrieveOutput = await posthog.agentApplicationsRetrieve();

// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...

`posthog.agentApplicationsPartialUpdate`

HTTP: PATCH /api/projects/{project_id}/agent_applications/{id}/
What it does: Agent applications — the deployable unit of the platform.

OpenAPI operationId: agent_applications_partial_update
Path params: id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsPartialUpdateInput = Parameters<typeof posthog.agentApplicationsPartialUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsPartialUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsPartialUpdate>>;

const result: AgentApplicationsPartialUpdateOutput = await posthog.agentApplicationsPartialUpdate();

// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...

`posthog.agentApplicationsUpdate`

HTTP: PUT /api/projects/{project_id}/agent_applications/{id}/
What it does: Agent applications — the deployable unit of the platform.

OpenAPI operationId: agent_applications_update
Path params: id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsUpdateInput = Parameters<typeof posthog.agentApplicationsUpdate> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsUpdateOutput = Awaited<ReturnType<typeof posthog.agentApplicationsUpdate>>;

const result: AgentApplicationsUpdateOutput = await posthog.agentApplicationsUpdate();

// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...

`posthog.agentApplicationsApprovalsList`

HTTP: GET /api/projects/{project_id}/agent_applications/{id}/approvals/
What it does: List approval-gated tool requests for this application. Team-admin only (per plan §6.1). Default returns all states — pass ?state=queued for the inbox view.
OpenAPI operationId: agent_applications_approvals_list
Path params: id
Query params: limit, offset, state
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { results: ({ id: string; session_id: string; application_id: string; team_id: number; revision_id: string; turn: number; tool_call_id: string; tool_name: string; proposed_args: { [key: string]: unknown }; decided_args:...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsApprovalsListInput = Parameters<typeof posthog.agentApplicationsApprovalsList> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsApprovalsListOutput = Awaited<ReturnType<typeof posthog.agentApplicationsApprovalsList>>;

const result: AgentApplicationsApprovalsListOutput = await posthog.agentApplicationsApprovalsList();

// Result shape (from schema): { results: ({ id: string; session_id: string; application_id: string; team_id: number; revision_id: string; turn: number; tool_call_id: string; tool_name: string; proposed_args: { [key: string]: unknown }; decided_args:...

`posthog.agentApplicationsApprovalsRetrieve`

HTTP: GET /api/projects/{project_id}/agent_applications/{id}/approvals/{approval_id}/
What it does: Single approval request — full proposed args, assistant snapshot, decision metadata, dispatch outcome. Team-admin only (plan §6.1).
OpenAPI operationId: agent_applications_approvals_retrieve
Path params: approval_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: unknown
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsApprovalsRetrieveInput = Parameters<typeof posthog.agentApplicationsApprovalsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsApprovalsRetrieveOutput = Awaited<ReturnType<typeof posthog.agentApplicationsApprovalsRetrieve>>;

const result: AgentApplicationsApprovalsRetrieveOutput = await posthog.agentApplicationsApprovalsRetrieve();

// Result shape (from schema): unknown

`posthog.agentApplicationsApprovalsDecide`

HTTP: POST /api/projects/{project_id}/agent_applications/{id}/approvals/{approval_id}/decide/
What it does: Approve or reject a queued agent-type tool-approval request.

This is the OWNER decision surface — the only PostHog-authoritative one: team admins decide here, in the console. principal-type approvals are decided by the session principal at the ingress decision API, not here. The runtime side runs the tool platform-side on approve and wakes the session with a synthetic tool_result either way.

OpenAPI operationId: agent_applications_approvals_decide
Path params: approval_id, id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { ok: boolean; state: string }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsApprovalsDecideInput = Parameters<typeof posthog.agentApplicationsApprovalsDecide> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsApprovalsDecideOutput = Awaited<ReturnType<typeof posthog.agentApplicationsApprovalsDecide>>;

const result: AgentApplicationsApprovalsDecideOutput = await posthog.agentApplicationsApprovalsDecide();

// Result shape (from schema): { ok: boolean; state: string }

`posthog.agentApplicationsPreviewProxyGet`

HTTP: GET /api/projects/{project_id}/agent_applications/{id}/preview-proxy/{rest}/
What it does: GET passthrough for the preview-proxy — used for /listen SSE.
OpenAPI operationId: agent_applications_preview_proxy_get
Path params: id, rest
Query params: format, revision_id
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsPreviewProxyGetInput = Parameters<typeof posthog.agentApplicationsPreviewProxyGet> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsPreviewProxyGetOutput = Awaited<ReturnType<typeof posthog.agentApplicationsPreviewProxyGet>>;

const result: AgentApplicationsPreviewProxyGetOutput = await posthog.agentApplicationsPreviewProxyGet();

// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...

`posthog.agentApplicationsPreviewProxy`

HTTP: POST /api/projects/{project_id}/agent_applications/{id}/preview-proxy/{rest}/
What it does: Authoring-side proxy for invoking a draft (or any non-live) revision.

Closes the anonymous-draft-invoke gap: the public ingress URL refuses non-live invokes that don't carry the x-agent-preview-secret header; this proxy attaches it after authenticating the Django caller.

URL: /api/projects/<team>/agent_applications/<app>/preview-proxy/<rest> Auth: standard PAT / session — agents:write scope (POST run/send/cancel is a mutating invoke; the read-only listen GET is agents:read).

OpenAPI operationId: agent_applications_preview_proxy
Path params: id, rest
Query params: format, revision_id
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: string
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsPreviewProxyInput = Parameters<typeof posthog.agentApplicationsPreviewProxy> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsPreviewProxyOutput = Awaited<ReturnType<typeof posthog.agentApplicationsPreviewProxy>>;

const result: AgentApplicationsPreviewProxyOutput = await posthog.agentApplicationsPreviewProxy();

// Result shape (from schema): string

`posthog.agentApplicationsPreviewToken`

HTTP: GET /api/projects/{project_id}/agent_applications/{id}/preview-token/
What it does: GET sibling of preview_token_mint. Same body and response shape — exists because EventSource can't set headers, so SSE callers fetch the token via GET and then attach ?preview_token= to the ingress URL. Behind the same URL (url_path="preview-token") thanks to DRF's @<action>.mapping.get; DRF resolves it to a distinct view.action, but it is in scope_object_write_actions alongside the POST sibling — both return a usable credential, so both require agents:write.
OpenAPI operationId: agent_applications_preview_token
Path params: id
Query params: revision_id
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { token: string; expires_in: number; ingress_slug: string; endpoints: unknown; auth: unknown; preview_proxy: unknown }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsPreviewTokenInput = Parameters<typeof posthog.agentApplicationsPreviewToken> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsPreviewTokenOutput = Awaited<ReturnType<typeof posthog.agentApplicationsPreviewToken>>;

const result: AgentApplicationsPreviewTokenOutput = await posthog.agentApplicationsPreviewToken();

// Result shape (from schema): { token: string; expires_in: number; ingress_slug: string; endpoints: unknown; auth: unknown; preview_proxy: unknown }

`posthog.agentApplicationsPreviewTokenMint`

HTTP: POST /api/projects/{project_id}/agent_applications/{id}/preview-token/
What it does: Mint a short-lived JWT for talking to a non-live revision directly via the public ingress URL. The caller attaches it as the x-agent-preview-token header (or ?preview_token= query param for EventSource). See _mint_preview_jwt for the payload + claim binding.

The response also includes endpoints, auth, and preview_proxy blocks so the caller can wire a preview invocation without grepping the agent-ingress source for which path each trigger exposes or which header name carries the token. This is the "self-describing" half of preview-mode — every piece of info you need to hit ingress is in one response.

POST is the canonical verb — minting credentials for downstream run/send/cancel is a write-class capability. A GET sibling exists at the same URL for EventSource callers (which can't set headers); it is also write-scoped, since it returns the same token.

OpenAPI operationId: agent_applications_preview_token_mint
Path params: id
Query params: revision_id
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { token: string; expires_in: number; ingress_slug: string; endpoints: unknown; auth: unknown; preview_proxy: unknown }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsPreviewTokenMintInput = Parameters<typeof posthog.agentApplicationsPreviewTokenMint> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsPreviewTokenMintOutput = Awaited<ReturnType<typeof posthog.agentApplicationsPreviewTokenMint>>;

const result: AgentApplicationsPreviewTokenMintOutput = await posthog.agentApplicationsPreviewTokenMint();

// Result shape (from schema): { token: string; expires_in: number; ingress_slug: string; endpoints: unknown; auth: unknown; preview_proxy: unknown }

`posthog.agentApplicationsSessionsList`

HTTP: GET /api/projects/{project_id}/agent_applications/{id}/sessions/
What it does: List sessions for this application, most recently active first. Strips the conversation transcript from each summary, but includes a preview (last assistant text, ~120 chars) and usage_total (token + cost aggregate). Use agent-applications-sessions-retrieve for the full transcript of a single session.
OpenAPI operationId: agent_applications_sessions_list
Path params: id
Query params: created_after, created_before, limit, offset, revision_id, state
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { results: ({ usage_total: { tokens_in: number; tokens_out: number; cache_read: number; cache_write: number; cost_input: number; cost_output: number; cost_cache_read: number; cost_cache_write: number; cost_total: number...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsSessionsListInput = Parameters<typeof posthog.agentApplicationsSessionsList> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsSessionsListOutput = Awaited<ReturnType<typeof posthog.agentApplicationsSessionsList>>;

const result: AgentApplicationsSessionsListOutput = await posthog.agentApplicationsSessionsList();

// Result shape (from schema): { results: ({ usage_total: { tokens_in: number; tokens_out: number; cache_read: number; cache_write: number; cost_input: number; cost_output: number; cost_cache_read: number; cost_cache_write: number; cost_total: number...

`posthog.agentApplicationsSessionsRetrieve`

HTTP: GET /api/projects/{project_id}/agent_applications/{id}/sessions/{session_id}/
What it does: Fetch one session's state — full conversation by default, or just the trailing N messages with ?last_n=. Always returns a usage_total block aggregated over the entire session, regardless of trim. The runner-side queue DB is the source of truth.
OpenAPI operationId: agent_applications_sessions_retrieve
Path params: id, session_id
Query params: last_n
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { usage_total: { tokens_in: number; tokens_out: number; cache_read: number; cache_write: number; cost_input: number; cost_output: number; cost_cache_read: number; cost_cache_write: number; cost_total: number }; principa...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsSessionsRetrieveInput = Parameters<typeof posthog.agentApplicationsSessionsRetrieve> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsSessionsRetrieveOutput = Awaited<ReturnType<typeof posthog.agentApplicationsSessionsRetrieve>>;

const result: AgentApplicationsSessionsRetrieveOutput = await posthog.agentApplicationsSessionsRetrieve();

// Result shape (from schema): { usage_total: { tokens_in: number; tokens_out: number; cache_read: number; cache_write: number; cost_input: number; cost_output: number; cost_cache_read: number; cost_cache_write: number; cost_total: number }; principa...

`posthog.agentApplicationsSessionLogs`

HTTP: GET /api/projects/{project_id}/agent_applications/{id}/sessions/{session_id}/logs/
What it does: Read the runner's structured event log for one session from ClickHouse. Filters (limit / after / before / level / search) match the shared LogEntryMixin helper used by hog_function + hog_flow.
OpenAPI operationId: agent_applications_session_logs
Path params: id, session_id
Query params: after, before, instance_id, level, limit, search
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { results: ({ log_source_id: string; instance_id: string; timestamp: string; level: string; message: string })[] }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsSessionLogsInput = Parameters<typeof posthog.agentApplicationsSessionLogs> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsSessionLogsOutput = Awaited<ReturnType<typeof posthog.agentApplicationsSessionLogs>>;

const result: AgentApplicationsSessionLogsOutput = await posthog.agentApplicationsSessionLogs();

// Result shape (from schema): { results: ({ log_source_id: string; instance_id: string; timestamp: string; level: string; message: string })[] }

`posthog.agentApplicationsStats`

HTTP: GET /api/projects/{project_id}/agent_applications/{id}/stats/
What it does: Roll-up stats for the agent — drives the agent-detail overview tiles.
OpenAPI operationId: agent_applications_stats
Path params: id
Query params: since
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { liveCount: number; sessionsInWindowCount: number; spendInWindowUsd: number; lastActivityAt: string | null; failedInWindowCount: number; pendingApprovalsCount: number }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsStatsInput = Parameters<typeof posthog.agentApplicationsStats> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsStatsOutput = Awaited<ReturnType<typeof posthog.agentApplicationsStats>>;

const result: AgentApplicationsStatsOutput = await posthog.agentApplicationsStats();

// Result shape (from schema): { liveCount: number; sessionsInWindowCount: number; spendInWindowUsd: number; lastActivityAt: string | null; failedInWindowCount: number; pendingApprovalsCount: number }

`posthog.agentApplicationsUsersList`

HTTP: GET /api/projects/{project_id}/agent_applications/{id}/users/
What it does: List this agent's end-users (the stable identities behind inbound principals) and each user's linked external connections. Connection metadata only — credential material is never returned.
OpenAPI operationId: agent_applications_users_list
Path params: id
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { count: number; results: ({ id: string; principal_kind: string; principal_id: string; metadata?: unknown; created_at: string; connections: ({ id: string; provider: string; scopes: (string)[]; state: string; subject?: s...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsUsersListInput = Parameters<typeof posthog.agentApplicationsUsersList> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsUsersListOutput = Awaited<ReturnType<typeof posthog.agentApplicationsUsersList>>;

const result: AgentApplicationsUsersListOutput = await posthog.agentApplicationsUsersList();

// Result shape (from schema): { count: number; results: ({ id: string; principal_kind: string; principal_id: string; metadata?: unknown; created_at: string; connections: ({ id: string; provider: string; scopes: (string)[]; state: string; subject?: s...

`posthog.agentApplicationsUsersConnectionDelete`

HTTP: DELETE /api/projects/{project_id}/agent_applications/{id}/users/{agent_user_id}/connections/{provider}/
What it does: Revoke one of an end-user's linked connections. The credential is marked revoked (kept for audit), so the agent can no longer act as that user on the provider.
OpenAPI operationId: agent_applications_users_connection_delete
Path params: agent_user_id, id, provider
Query params: None
Response codes: 204
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: unknown
OpenAPI response codes: 204

import posthog from "@utdk/posthog";

type AgentApplicationsUsersConnectionDeleteInput = Parameters<typeof posthog.agentApplicationsUsersConnectionDelete> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsUsersConnectionDeleteOutput = Awaited<ReturnType<typeof posthog.agentApplicationsUsersConnectionDelete>>;

const result: AgentApplicationsUsersConnectionDeleteOutput = await posthog.agentApplicationsUsersConnectionDelete();

// Result shape (from schema): unknown

`posthog.agentApplicationsModels`

HTTP: GET /api/projects/{project_id}/agent_applications/models/
What it does: Served-model catalog — each model's id, provider, context window, and USD-per-million-token pricing — plus the curated auto-level → model map. Project-agnostic; sourced from the AI gateway catalog. Powers the config UI model browser and the agent builder's model-choosing skill.
OpenAPI operationId: agent_applications_models
Path params: None
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsModelsInput = Parameters<typeof posthog.agentApplicationsModels> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsModelsOutput = Awaited<ReturnType<typeof posthog.agentApplicationsModels>>;

const result: AgentApplicationsModelsOutput = await posthog.agentApplicationsModels();

// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...

`posthog.agentApplicationsSpecSchema`

HTTP: GET /api/projects/{project_id}/agent_applications/spec_schema/
What it does: The canonical JSON Schema for an agent spec — every field, type, enum, default, and the discriminated unions for models / triggers[] / tools[], each with an inline description. Emitted from the same source the runner validates against (fields with a default are optional on write), so read it BEFORE composing a spec for create / revisions-spec-update instead of guessing the shape. Pass section to fetch just one part.
OpenAPI operationId: agent_applications_spec_schema
Path params: None
Query params: section
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentApplicationsSpecSchemaInput = Parameters<typeof posthog.agentApplicationsSpecSchema> extends [infer T, ...unknown[]] ? T : undefined;
type AgentApplicationsSpecSchemaOutput = Awaited<ReturnType<typeof posthog.agentApplicationsSpecSchema>>;

const result: AgentApplicationsSpecSchemaOutput = await posthog.agentApplicationsSpecSchema();

// Result shape (from schema): { id: string; team_id: number; name: string; slug?: string; description?: string; live_revision: string | null; archived?: boolean; archived_at: string | null; created_by_id: number | null; created_by: { [key: string]: ...

`posthog.agentFleetApprovalsList`

HTTP: GET /api/projects/{project_id}/agent_fleet/approvals/
What it does: Approval-gated tool requests across every agent in this team. Team-admin only.
OpenAPI operationId: agent_fleet_approvals_list
Path params: None
Query params: agent_id, limit, offset, state
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: unknown
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentFleetApprovalsListInput = Parameters<typeof posthog.agentFleetApprovalsList> extends [infer T, ...unknown[]] ? T : undefined;
type AgentFleetApprovalsListOutput = Awaited<ReturnType<typeof posthog.agentFleetApprovalsList>>;

const result: AgentFleetApprovalsListOutput = await posthog.agentFleetApprovalsList();

// Result shape (from schema): unknown

`posthog.agentFleetLiveSessions`

HTTP: GET /api/projects/{project_id}/agent_fleet/live_sessions/
What it does: Live (non-terminal) sessions across every agent owned by this team, newest activity first.
OpenAPI operationId: agent_fleet_live_sessions
Path params: None
Query params: limit
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { results: ({ usage_total: { tokens_in: number; tokens_out: number; cache_read: number; cache_write: number; cost_input: number; cost_output: number; cost_cache_read: number; cost_cache_write: number; cost_total: number...
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentFleetLiveSessionsInput = Parameters<typeof posthog.agentFleetLiveSessions> extends [infer T, ...unknown[]] ? T : undefined;
type AgentFleetLiveSessionsOutput = Awaited<ReturnType<typeof posthog.agentFleetLiveSessions>>;

const result: AgentFleetLiveSessionsOutput = await posthog.agentFleetLiveSessions();

// Result shape (from schema): { results: ({ usage_total: { tokens_in: number; tokens_out: number; cache_read: number; cache_write: number; cost_input: number; cost_output: number; cost_cache_read: number; cost_cache_write: number; cost_total: number...

`posthog.agentFleetStats`

HTTP: GET /api/projects/{project_id}/agent_fleet/stats/
What it does: Roll-up stats across every agent owned by this team.
OpenAPI operationId: agent_fleet_stats
Path params: None
Query params: since
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: { liveCount: number; sessionsInWindowCount: number; spendInWindowUsd: number; lastActivityAt: string | null; failedInWindowCount: number; pendingApprovalsCount: number }
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentFleetStatsInput = Parameters<typeof posthog.agentFleetStats> extends [infer T, ...unknown[]] ? T : undefined;
type AgentFleetStatsOutput = Awaited<ReturnType<typeof posthog.agentFleetStats>>;

const result: AgentFleetStatsOutput = await posthog.agentFleetStats();

// Result shape (from schema): { liveCount: number; sessionsInWindowCount: number; spendInWindowUsd: number; lastActivityAt: string | null; failedInWindowCount: number; pendingApprovalsCount: number }

`posthog.agentNativeToolsList`

HTTP: GET /api/projects/{project_id}/agent_native_tools/
What it does: Read-only catalog of every @posthog/* native tool the runner knows.
OpenAPI operationId: agent_native_tools_list
Path params: None
Query params: None
Response codes: 200
Transport options: None
TypeScript: Client interface

Inputs

Client input type: { [key: string]: unknown }
Client transport options: None

Outputs

Client return type: ({ tools: ({ id: string; schema: { [key: string]: unknown } })[] })[]
OpenAPI response codes: 200

import posthog from "@utdk/posthog";

type AgentNativeToolsListInput = Parameters<typeof posthog.agentNativeToolsList> extends [infer T, ...unknown[]] ? T : undefined;
type AgentNativeToolsListOutput = Awaited<ReturnType<typeof posthog.agentNativeToolsList>>;

const result: AgentNativeToolsListOutput = await posthog.agentNativeToolsList();

// Result shape (from schema): ({ tools: ({ id: string; schema: { [key: string]: unknown } })[] })[]