agent reference

static list(): Promise<Agent[]>;

const agents = await agent.list();

static get(agentId: string): Promise<Agent>;

const one = await agent.get(agentId);

static create(data: AgentCreateInput): Promise<Agent>;

const created = await agent.create({
  name: 'Ops copilot',
  serviceAccountUserId: userId,
});

static update(agentId: string, data: AgentUpdateInput): Promise<Agent>;

const updated = await agent.update(agentId, {
  desc: 'Handles operational runbooks.',
});

static listInbox(agentId: string): Promise<AgentInboxItem[]>;

const inbox = await agent.listInbox(agentId);

static getInboxItem(
      agentId: string,
      agentInboxItemId: string,
    ): Promise<AgentInboxItem>;

const item = await agent.getInboxItem(agentId, agentInboxItemId);

static pushInbox(
      agentId: string,
      data: AgentInboxItemCreateInput,
    ): Promise<AgentInboxItem>;

const item = await agent.pushInbox(agentId, {
  instruction: 'Review failed deploy logs.',
});

static updateInboxItem(
      agentId: string,
      agentInboxItemId: string,
      data: AgentInboxItemUpdateInput,
    ): Promise<AgentInboxItem>;

const item = await agent.updateInboxItem(agentId, agentInboxItemId, {
  instruction: 'Review the updated deployment evidence.',
});

static removeInboxItem(
      agentId: string,
      agentInboxItemId: string,
    ): Promise<AgentInboxItem>;

await agent.removeInboxItem(agentId, agentInboxItemId);

static listPlugins(agentId: string): Promise<AgentPlugin[]>;

const tools = await agent.listPlugins(agentId);

static getPlugin(
      agentId: string,
      toolId: string,
    ): Promise<AgentPlugin>;

const tool = await agent.getPlugin(agentId, toolId);

static listRuns(agentId: string): Promise<AgentRun[]>;

const runs = await agent.listRuns(agentId);

static getRun(agentRunId: string): Promise<AgentRun>;

const run = await agent.getRun(agentRunId);

static listRunEvents(agentRunId: string): Promise<AgentRunEvent[]>;

const events = await agent.listRunEvents(agentRunId);

static listRunThreads(agentRunId: string): Promise<AgentRunThread[]>;

const threads = await agent.listRunThreads(agentRunId);

static startRun(agentId: string, data: AgentRunInput): Promise<AgentRun>;

const run = await agent.startRun(agentId, {
  instruction: 'Summarize today\\'s alerts.',
});

static resumeRun(agentRunId: string): Promise<AgentRun>;

const run = await agent.resumeRun(agentRunId);

static retryRun(agentRunId: string): Promise<AgentRun>;

const run = await agent.retryRun(agentRunId);

static tickRun(agentRunId: string): Promise<AgentRun>;

const run = await agent.tickRun(agentRunId);

static cancelRun(
      agentRunId: string,
      data?: AgentRunCancelInput,
    ): Promise<AgentRun>;

const run = await agent.cancelRun(agentRunId, { reason: 'Operator stop' });

static reconcileRuns(): Promise<any>;

await agent.reconcileRuns();

static listThreads(
      query?: Record<string, any>,
    ): Promise<CollectionResult<AssistantThread>>;

const threads = await agent.listThreads({ take: 20 });

static getThread(
      assistantThreadId: string,
      options?: { hideDeleted?: boolean },
    ): Promise<AssistantThread>;

const thread = await agent.getThread(assistantThreadId);

static getThreadState(
      assistantThreadId: string,
    ): Promise<AssistantThreadState>;

const state = await agent.getThreadState(assistantThreadId);

static getThreadGoal(
      assistantThreadId: string,
    ): Promise<AssistantThreadGoal | null>;

static setThreadGoal(
      assistantThreadId: string,
      data: AssistantThreadGoalInput,
    ): Promise<AssistantThreadGoal>;

static pauseThreadGoal(
      assistantThreadId: string,
    ): Promise<AssistantThreadGoal>;

static resumeThreadGoal(
      assistantThreadId: string,
    ): Promise<AssistantThreadGoal>;

static clearThreadGoal(
      assistantThreadId: string,
    ): Promise<AssistantThreadGoal>;

static getThreadShare(
      assistantThreadId: string,
    ): Promise<AssistantThreadShare | null>;

const share = await agent.getThreadShare(assistantThreadId);

static enableThreadShare(
      assistantThreadId: string,
    ): Promise<AssistantThreadShare>;

const share = await agent.enableThreadShare(assistantThreadId);

static disableThreadShare(
      assistantThreadId: string,
    ): Promise<AssistantThreadShare>;

await agent.disableThreadShare(assistantThreadId);

static getSharedThread(
      shareId: string,
    ): Promise<AssistantSharedThreadResponse>;

const shared = await agent.getSharedThread(shareId);

static listSharedThreadMessages(
      shareId: string,
      query?: Record<string, any>,
    ): Promise<CollectionResult<AssistantMessage>>;

const messages = await agent.listSharedThreadMessages(shareId, { take: 50 });

static getSharedThreadMessageExecutionDetails(
      shareId: string,
      assistantMessageId: string,
    ): Promise<Record<string, any>>;

const details = await agent.getSharedThreadMessageExecutionDetails(shareId, assistantMessageId);

static getSharedThreadMessageArtifact(
      shareId: string,
      assistantMessageId: string,
      artifactId: string,
    ): Promise<Record<string, any>>;

const artifact = await agent.getSharedThreadMessageArtifact(shareId, assistantMessageId, artifactId);

static forkSharedThreadMessage(
      shareId: string,
      assistantMessageId: string,
      data?: AssistantForkMessageInput,
    ): Promise<AssistantThreadResponse>;

const fork = await agent.forkSharedThreadMessage(shareId, assistantMessageId);

static createThread(
      data: AssistantMessageInput,
    ): Promise<AssistantThreadResponse>;

const response = await agent.createThread({ content: 'Draft a release note.' });

static deleteThread(assistantThreadId: string): Promise<void>;

await agent.deleteThread(assistantThreadId);

static restoreThread(assistantThreadId: string): Promise<void>;

await agent.restoreThread(assistantThreadId);

static listThreadMessages(
      assistantThreadId: string,
      query?: Record<string, any>,
    ): Promise<CollectionResult<AssistantMessage>>;

const messages = await agent.listThreadMessages(assistantThreadId, { take: 50 });

static sendMessage(
      assistantThreadId: string,
      data: AssistantMessageInput,
    ): Promise<AssistantThreadResponse>;

const response = await agent.sendMessage(assistantThreadId, {
  content: 'Continue with the rollout checklist.',
});

static retryMessage(
      assistantThreadId: string,
      assistantMessageId: string,
    ): Promise<AssistantThreadResponse>;

const response = await agent.retryMessage(assistantThreadId, assistantMessageId);

static cancelThread(assistantThreadId: string, expectedVersion: number): Promise<void>;

await agent.cancelThread(assistantThreadId, thread.version);

static forkMessage(
      assistantThreadId: string,
      assistantMessageId: string,
      data?: AssistantForkMessageInput,
    ): Promise<AssistantThreadResponse>;

const fork = await agent.forkMessage(assistantThreadId, assistantMessageId);

static renameThread(
      assistantThreadId: string,
      data: AssistantThreadTitleInput,
    ): Promise<AssistantThread>;

const thread = await agent.renameThread(assistantThreadId, {
  title: 'Postmortem draft',
});

static resolveAction(
      assistantThreadId: string,
      assistantActionRequiredId: string,
      data: AssistantActionResolutionInput,
    ): Promise<AssistantThreadResponse>;

const response = await agent.resolveAction(assistantThreadId, actionId, {
  decision: 'approve',
});

static approveAction(
      assistantThreadId: string,
      assistantActionRequiredId: string,
      options?: Omit<AssistantActionResolutionInput, 'decision'>,
    ): Promise<AssistantThreadResponse>;

const response = await agent.approveAction(assistantThreadId, actionId);

static rejectAction(
      assistantThreadId: string,
      assistantActionRequiredId: string,
      options?: Omit<AssistantActionResolutionInput, 'decision'>,
    ): Promise<AssistantThreadResponse>;

const response = await agent.rejectAction(assistantThreadId, actionId, {
  responseText: 'Need a narrower scope.',
});

static submitAction(
      assistantThreadId: string,
      assistantActionRequiredId: string,
      options?: Omit<AssistantActionResolutionInput, 'decision'>,
    ): Promise<AssistantThreadResponse>;

const response = await agent.submitAction(assistantThreadId, actionId, {
  responsePayload: { selectedPlanId: 'plan-1' },
});

static compactThread(
      assistantThreadId: string,
      options?: AssistantThreadCompactionRequest,
    ): Promise<AssistantThread>;

const thread = await agent.compactThread(assistantThreadId, {
  force: true,
});