contentful-management 11.66.0 → 11.67.1

package/dist/es-modules/adapters/REST/endpoints/agent-run.js

@@ -0,0 +1,20 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as raw from './raw';
+const AgentRunAlphaHeaders = {
+  'x-contentful-enable-alpha-feature': 'agents-api'
+};
+export const get = (http, params, headers) => {
+  return raw.get(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/ai_agents/runs/${params.runId}`, {
+    headers: _objectSpread(_objectSpread({}, AgentRunAlphaHeaders), headers)
+  });
+};
+export const getMany = (http, params, headers) => {
+  return raw.get(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/ai_agents/runs`, {
+    params: params.query,
+    headers: _objectSpread(_objectSpread({}, AgentRunAlphaHeaders), headers)
+  });
+};

package/dist/es-modules/adapters/REST/endpoints/agent.js

@@ -0,0 +1,24 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as raw from './raw';
+const AgentAlphaHeaders = {
+  'x-contentful-enable-alpha-feature': 'agents-api'
+};
+export const get = (http, params, headers) => {
+  return raw.get(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/ai_agents/agents/${params.agentId}`, {
+    headers: _objectSpread(_objectSpread({}, AgentAlphaHeaders), headers)
+  });
+};
+export const getMany = (http, params, headers) => {
+  return raw.get(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/ai_agents/agents`, {
+    headers: _objectSpread(_objectSpread({}, AgentAlphaHeaders), headers)
+  });
+};
+export const generate = (http, params, data, headers) => {
+  return raw.post(http, `/spaces/${params.spaceId}/environments/${params.environmentId}/ai_agents/agents/${params.agentId}/generate`, data, {
+    headers: _objectSpread(_objectSpread({}, AgentAlphaHeaders), headers)
+  });
+};

package/dist/es-modules/adapters/REST/endpoints/index.js

@@ -1,5 +1,7 @@
 import * as AiAction from './ai-action';
 import * as AiActionInvocation from './ai-action-invocation';
+import * as Agent from './agent';
+import * as AgentRun from './agent-run';
 import * as AccessToken from './access-token';
 import * as ApiKey from './api-key';
 import * as AppAccessToken from './app-access-token';
@@ -74,6 +76,8 @@ import * as WorkflowsChangelog from './workflows-changelog';
 export default {
   AiAction,
   AiActionInvocation,
+  Agent,
+  AgentRun,
   ApiKey,
   AppAction,
   AppActionCall,

package/dist/es-modules/create-environment-api.js

@@ -85,6 +85,14 @@ export default function createEnvironmentApi(makeRequest) {
   const {
     wrapAppAccessToken
   } = entities.appAccessToken;
+  const {
+    wrapAgent,
+    wrapAgentCollection
+  } = entities.agent;
+  const {
+    wrapAgentRun,
+    wrapAgentRunCollection
+  } = entities.agentRun;
   const {
     wrapResourceTypesForEnvironmentCollection
   } = entities.resourceType;
@@ -2845,6 +2853,171 @@ export default function createEnvironmentApi(makeRequest) {
         },
         payload
       }).then(data => wrapSemanticSearch(makeRequest, data));
+    },
+    /**
+     * Gets an AI Agent
+     * @param agentId - AI Agent ID
+     * @return Promise for an AI Agent
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.getEnvironment('<environment_id>'))
+     *   .then((environment) => environment.getAgent('<agent_id>'))
+     *   .then((agent) => console.log(agent))
+     *   .catch(console.error)
+     * ```
+     */
+    getAgent(agentId) {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Agent',
+        action: 'get',
+        params: {
+          spaceId: raw.sys.space.sys.id,
+          environmentId: raw.sys.id,
+          agentId
+        }
+      }).then(data => wrapAgent(makeRequest, data));
+    },
+    /**
+     * Gets a collection of AI Agents
+     * @return Promise for a collection of AI Agents
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.getEnvironment('<environment_id>'))
+     *   .then((environment) => environment.getAgents())
+     *   .then((response) => console.log(response.items))
+     *   .catch(console.error)
+     * ```
+     */
+    getAgents() {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Agent',
+        action: 'getMany',
+        params: {
+          spaceId: raw.sys.space.sys.id,
+          environmentId: raw.sys.id
+        }
+      }).then(data => wrapAgentCollection(makeRequest, data));
+    },
+    /**
+     * Generates content using an AI Agent
+     * @param agentId - AI Agent ID
+     * @param payload - Generation payload
+     * @return Promise for the generation response
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.getEnvironment('<environment_id>'))
+     *   .then((environment) => environment.generateWithAgent('<agent_id>', {
+     *     messages: [
+     *       {
+     *         parts: [
+     *           {
+     *             type: 'text',
+     *             text: 'Write a short poem about Contentful'
+     *           }
+     *         ],
+     *         role: 'user'
+     *       }
+     *     ]
+     *   }))
+     *   .then((result) => console.log(result))
+     *   .catch(console.error)
+     * ```
+     */
+    generateWithAgent(agentId, payload) {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Agent',
+        action: 'generate',
+        params: {
+          spaceId: raw.sys.space.sys.id,
+          environmentId: raw.sys.id,
+          agentId
+        },
+        payload
+      }).then(data => wrapAgentRun(makeRequest, data));
+    },
+    /**
+     * Gets an AI Agent Run
+     * @param runId - AI Agent Run ID
+     * @return Promise for an AI Agent Run
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.getEnvironment('<environment_id>'))
+     *   .then((environment) => environment.getAgentRun('<run_id>'))
+     *   .then((run) => console.log(run))
+     *   .catch(console.error)
+     * ```
+     */
+    getAgentRun(runId) {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'AgentRun',
+        action: 'get',
+        params: {
+          spaceId: raw.sys.space.sys.id,
+          environmentId: raw.sys.id,
+          runId
+        }
+      }).then(data => wrapAgentRun(makeRequest, data));
+    },
+    /**
+     * Gets a collection of AI Agent Runs with optional filtering
+     * @param query - Object with search parameters (agentIn, statusIn)
+     * @return Promise for a collection of AI Agent Runs
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.getEnvironment('<environment_id>'))
+     *   .then((environment) => environment.getAgentRuns({
+     *     agentIn: ['agent1', 'agent2'],
+     *     statusIn: ['COMPLETED', 'IN_PROGRESS']
+     *   }))
+     *   .then((response) => console.log(response.items))
+     *   .catch(console.error)
+     * ```
+     */
+    getAgentRuns(query = {}) {
+      const raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'AgentRun',
+        action: 'getMany',
+        params: {
+          spaceId: raw.sys.space.sys.id,
+          environmentId: raw.sys.id,
+          query
+        }
+      }).then(data => wrapAgentRunCollection(makeRequest, data));
     }
   };
 }

package/dist/es-modules/entities/agent-run.js

@@ -0,0 +1,8 @@
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils';
+export function wrapAgentRun(_makeRequest, data) {
+  const agentRun = toPlainObject(copy(data));
+  return freezeSys(agentRun);
+}
+export const wrapAgentRunCollection = wrapCollection(wrapAgentRun);

package/dist/es-modules/entities/agent.js

@@ -0,0 +1,29 @@
+import { freezeSys, toPlainObject } from 'contentful-sdk-core';
+import copy from 'fast-copy';
+import { wrapCollection } from '../common-utils';
+import enhanceWithMethods from '../enhance-with-methods';
+import { wrapAgentRun } from './agent-run';
+function createAgentApi(makeRequest) {
+  const getParams = data => ({
+    spaceId: data.sys.space.sys.id,
+    environmentId: data.sys.environment.sys.id,
+    agentId: data.sys.id
+  });
+  return {
+    generate: function generate(payload) {
+      const self = this;
+      return makeRequest({
+        entityType: 'Agent',
+        action: 'generate',
+        params: getParams(self),
+        payload
+      }).then(data => wrapAgentRun(makeRequest, data));
+    }
+  };
+}
+export function wrapAgent(makeRequest, data) {
+  const agent = toPlainObject(copy(data));
+  const agentWithMethods = enhanceWithMethods(agent, createAgentApi(makeRequest));
+  return freezeSys(agentWithMethods);
+}
+export const wrapAgentCollection = wrapCollection(wrapAgent);

package/dist/es-modules/entities/index.js

@@ -1,5 +1,7 @@
 import * as aiAction from './ai-action';
 import * as aiActionInvocation from './ai-action-invocation';
+import * as agent from './agent';
+import * as agentRun from './agent-run';
 import * as apiKey from './api-key';
 import * as appAction from './app-action';
 import * as appActionCall from './app-action-call';
@@ -68,6 +70,8 @@ import * as resource from './resource';
 export default {
   aiAction,
   aiActionInvocation,
+  agent,
+  agentRun,
   accessToken,
   appAction,
   appActionCall,

package/dist/es-modules/plain/entities/agent-run.js

@@ -0,0 +1 @@
+export {};

package/dist/es-modules/plain/entities/agent.js

@@ -0,0 +1 @@
+export {};

package/dist/es-modules/plain/plain-client.js

@@ -81,6 +81,15 @@ export const createPlainClient = (makeRequest, defaults) => {
     aiActionInvocation: {
       get: wrap(wrapParams, 'AiActionInvocation', 'get')
     },
+    agent: {
+      get: wrap(wrapParams, 'Agent', 'get'),
+      getMany: wrap(wrapParams, 'Agent', 'getMany'),
+      generate: wrap(wrapParams, 'Agent', 'generate')
+    },
+    agentRun: {
+      get: wrap(wrapParams, 'AgentRun', 'get'),
+      getMany: wrap(wrapParams, 'AgentRun', 'getMany')
+    },
     appAction: {
       get: wrap(wrapParams, 'AppAction', 'get'),
       getMany: wrap(wrapParams, 'AppAction', 'getMany'),

package/dist/typings/adapters/REST/endpoints/agent-run.d.ts

@@ -0,0 +1,3 @@
+import type { RestEndpoint } from '../types';
+export declare const get: RestEndpoint<'AgentRun', 'get'>;
+export declare const getMany: RestEndpoint<'AgentRun', 'getMany'>;

package/dist/typings/adapters/REST/endpoints/agent.d.ts

@@ -0,0 +1,4 @@
+import type { RestEndpoint } from '../types';
+export declare const get: RestEndpoint<'Agent', 'get'>;
+export declare const getMany: RestEndpoint<'Agent', 'getMany'>;
+export declare const generate: RestEndpoint<'Agent', 'generate'>;

package/dist/typings/adapters/REST/endpoints/index.d.ts

@@ -1,5 +1,7 @@
 import * as AiAction from './ai-action';
 import * as AiActionInvocation from './ai-action-invocation';
+import * as Agent from './agent';
+import * as AgentRun from './agent-run';
 import * as AccessToken from './access-token';
 import * as ApiKey from './api-key';
 import * as AppAccessToken from './app-access-token';
@@ -74,6 +76,8 @@ import * as WorkflowsChangelog from './workflows-changelog';
 declare const _default: {
     AiAction: typeof AiAction;
     AiActionInvocation: typeof AiActionInvocation;
+    Agent: typeof Agent;
+    AgentRun: typeof AgentRun;
     ApiKey: typeof ApiKey;
     AppAction: typeof AppAction;
     AppActionCall: typeof AppActionCall;

package/dist/typings/common-types.d.ts

@@ -64,6 +64,8 @@ import type { CreateOAuthApplicationProps, OAuthApplicationProps, UpdateOAuthApp
 import type { FunctionLogProps } from './entities/function-log';
 import type { AiActionProps, AiActionQueryOptions, CreateAiActionProps } from './entities/ai-action';
 import type { AiActionInvocationProps, AiActionInvocationType } from './entities/ai-action-invocation';
+import type { AgentGeneratePayload, AgentProps } from './entities/agent';
+import type { AgentRunProps, AgentRunQueryOptions } from './entities/agent-run';
 import type { UpdateVectorizationStatusProps, VectorizationStatusProps } from './entities/vectorization-status';
 import type { GetSemanticDuplicatesProps, SemanticDuplicatesProps } from './entities/semantic-duplicates';
 import type { GetSemanticRecommendationsProps, SemanticRecommendationsProps } from './entities/semantic-recommendations';
@@ -267,6 +269,11 @@ type MRInternal<UA extends boolean> = {
     (opts: MROpts<'AiAction', 'unpublish', UA>): MRReturn<'AiAction', 'unpublish'>;
     (opts: MROpts<'AiAction', 'invoke', UA>): MRReturn<'AiAction', 'invoke'>;
     (opts: MROpts<'AiActionInvocation', 'get', UA>): MRReturn<'AiActionInvocation', 'get'>;
+    (opts: MROpts<'Agent', 'get', UA>): MRReturn<'Agent', 'get'>;
+    (opts: MROpts<'Agent', 'getMany', UA>): MRReturn<'Agent', 'getMany'>;
+    (opts: MROpts<'Agent', 'generate', UA>): MRReturn<'Agent', 'generate'>;
+    (opts: MROpts<'AgentRun', 'get', UA>): MRReturn<'AgentRun', 'get'>;
+    (opts: MROpts<'AgentRun', 'getMany', UA>): MRReturn<'AgentRun', 'getMany'>;
     (opts: MROpts<'AppAction', 'get', UA>): MRReturn<'AppAction', 'get'>;
     (opts: MROpts<'AppAction', 'getMany', UA>): MRReturn<'AppAction', 'getMany'>;
     (opts: MROpts<'AppAction', 'delete', UA>): MRReturn<'AppAction', 'delete'>;
@@ -793,6 +800,44 @@ export type MRActions = {
             return: AiActionInvocationProps;
         };
     };
+    Agent: {
+        get: {
+            params: GetSpaceEnvironmentParams & {
+                agentId: string;
+            };
+            headers?: RawAxiosRequestHeaders;
+            return: AgentProps;
+        };
+        getMany: {
+            params: GetSpaceEnvironmentParams;
+            headers?: RawAxiosRequestHeaders;
+            return: CollectionProp<AgentProps>;
+        };
+        generate: {
+            params: GetSpaceEnvironmentParams & {
+                agentId: string;
+            };
+            payload: AgentGeneratePayload;
+            headers?: RawAxiosRequestHeaders;
+            return: AgentRunProps;
+        };
+    };
+    AgentRun: {
+        get: {
+            params: GetSpaceEnvironmentParams & {
+                runId: string;
+            };
+            headers?: RawAxiosRequestHeaders;
+            return: AgentRunProps;
+        };
+        getMany: {
+            params: GetSpaceEnvironmentParams & {
+                query?: AgentRunQueryOptions;
+            };
+            headers?: RawAxiosRequestHeaders;
+            return: CollectionProp<AgentRunProps>;
+        };
+    };
     AppAction: {
         get: {
             params: GetAppActionParams;

package/dist/typings/create-environment-api.d.ts

@@ -17,6 +17,8 @@ import type { TagVisibility } from './entities/tag';
 import type { CreateAppAccessTokenProps } from './entities/app-access-token';
 import type { ResourceQueryOptions } from './entities/resource';
 import type { AiActionInvocationType } from './entities/ai-action-invocation';
+import type { AgentGeneratePayload } from './entities/agent';
+import type { AgentRunQueryOptions } from './entities/agent-run';
 import type { GetSemanticDuplicatesProps } from './entities/semantic-duplicates';
 import type { GetSemanticRecommendationsProps } from './entities/semantic-recommendations';
 import type { GetSemanticReferenceSuggestionsProps } from './entities/semantic-reference-suggestions';
@@ -1849,4 +1851,114 @@ export default function createEnvironmentApi(makeRequest: MakeRequest): {
      *    })
      */
     getSemanticSearch(payload: GetSemanticSearchProps): Promise<import("./entities/semantic-search").SemanticSearch>;
+    /**
+     * Gets an AI Agent
+     * @param agentId - AI Agent ID
+     * @return Promise for an AI Agent
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.getEnvironment('<environment_id>'))
+     *   .then((environment) => environment.getAgent('<agent_id>'))
+     *   .then((agent) => console.log(agent))
+     *   .catch(console.error)
+     * ```
+     */
+    getAgent(agentId: string): Promise<import("./entities/agent").Agent>;
+    /**
+     * Gets a collection of AI Agents
+     * @return Promise for a collection of AI Agents
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.getEnvironment('<environment_id>'))
+     *   .then((environment) => environment.getAgents())
+     *   .then((response) => console.log(response.items))
+     *   .catch(console.error)
+     * ```
+     */
+    getAgents(): Promise<import("./common-types").Collection<import("./entities/agent").Agent, import("./entities/agent").AgentProps>>;
+    /**
+     * Generates content using an AI Agent
+     * @param agentId - AI Agent ID
+     * @param payload - Generation payload
+     * @return Promise for the generation response
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.getEnvironment('<environment_id>'))
+     *   .then((environment) => environment.generateWithAgent('<agent_id>', {
+     *     messages: [
+     *       {
+     *         parts: [
+     *           {
+     *             type: 'text',
+     *             text: 'Write a short poem about Contentful'
+     *           }
+     *         ],
+     *         role: 'user'
+     *       }
+     *     ]
+     *   }))
+     *   .then((result) => console.log(result))
+     *   .catch(console.error)
+     * ```
+     */
+    generateWithAgent(agentId: string, payload: AgentGeneratePayload): Promise<import("./entities/agent-run").AgentRun>;
+    /**
+     * Gets an AI Agent Run
+     * @param runId - AI Agent Run ID
+     * @return Promise for an AI Agent Run
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.getEnvironment('<environment_id>'))
+     *   .then((environment) => environment.getAgentRun('<run_id>'))
+     *   .then((run) => console.log(run))
+     *   .catch(console.error)
+     * ```
+     */
+    getAgentRun(runId: string): Promise<import("./entities/agent-run").AgentRun>;
+    /**
+     * Gets a collection of AI Agent Runs with optional filtering
+     * @param query - Object with search parameters (agentIn, statusIn)
+     * @return Promise for a collection of AI Agent Runs
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     *   .then((space) => space.getEnvironment('<environment_id>'))
+     *   .then((environment) => environment.getAgentRuns({
+     *     agentIn: ['agent1', 'agent2'],
+     *     statusIn: ['COMPLETED', 'IN_PROGRESS']
+     *   }))
+     *   .then((response) => console.log(response.items))
+     *   .catch(console.error)
+     * ```
+     */
+    getAgentRuns(query?: AgentRunQueryOptions): Promise<import("./common-types").Collection<import("./entities/agent-run").AgentRun, import("./entities/agent-run").AgentRunProps>>;
 };

package/dist/typings/entities/agent-run.d.ts

@@ -0,0 +1,47 @@
+import type { DefaultElements, Link, MakeRequest, MetaSysProps } from '../common-types';
+export type AgentRunStatus = 'IN_PROGRESS' | 'FAILED' | 'COMPLETED' | 'PENDING_REVIEW' | 'DRAFT';
+export type AgentRunMessageRole = 'system' | 'user' | 'assistant' | 'tool';
+export type AgentRunMessageTextPart = {
+    type: 'text';
+    text: string;
+};
+export type AgentRunMessageToolCallPart = {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+};
+export type AgentRunMessagePart = AgentRunMessageTextPart | AgentRunMessageToolCallPart;
+export type AgentRunMessage = {
+    id: string;
+    createdAt: string;
+    role: AgentRunMessageRole;
+    content: {
+        parts: Array<AgentRunMessagePart>;
+    };
+};
+export type AgentRunProps = {
+    sys: MetaSysProps & {
+        type: 'AgentRun';
+        createdAt: string;
+        updatedAt?: string;
+        status: AgentRunStatus;
+        id: string;
+    };
+    agent: {
+        sys: Link<'Agent'>;
+    };
+    space: {
+        sys: Link<'Space'>;
+    };
+    title: string;
+    messages: Array<AgentRunMessage>;
+};
+export type AgentRunQueryOptions = {
+    agentIn?: string[];
+    statusIn?: AgentRunStatus[];
+};
+export interface AgentRun extends AgentRunProps, DefaultElements<AgentRunProps> {
+}
+export declare function wrapAgentRun(_makeRequest: MakeRequest, data: AgentRunProps): AgentRun;
+export declare const wrapAgentRunCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AgentRunProps>) => import("../common-types").Collection<AgentRun, AgentRunProps>;

package/dist/typings/entities/agent.d.ts

@@ -0,0 +1,49 @@
+import type { DefaultElements, MakeRequest, MetaSysProps } from '../common-types';
+import { type AgentRun } from './agent-run';
+export type AgentToolLink = {
+    sys: {
+        type: 'Link';
+        linkType: 'AgentTool';
+        id: string;
+    };
+};
+export type AgentProps = {
+    sys: MetaSysProps & {
+        type: 'Agent';
+        space: {
+            sys: {
+                id: string;
+            };
+        };
+        environment: {
+            sys: {
+                id: string;
+            };
+        };
+        createdAt: string;
+        id: string;
+    };
+    name: string;
+    description: string;
+    tools?: Array<AgentToolLink>;
+    provider?: string;
+    modelId?: string;
+};
+type AgentMessageRole = 'system' | 'user' | 'assistant' | 'tool';
+export type AgentGeneratePayload = {
+    messages: Array<{
+        parts: Array<{
+            type: 'text';
+            text: string;
+        }>;
+        id?: string;
+        role: AgentMessageRole;
+    }>;
+    threadId?: string;
+};
+export interface Agent extends AgentProps, DefaultElements<AgentProps> {
+    generate(payload: AgentGeneratePayload): Promise<AgentRun>;
+}
+export declare function wrapAgent(makeRequest: MakeRequest, data: AgentProps): Agent;
+export declare const wrapAgentCollection: (makeRequest: MakeRequest, data: import("../common-types").CollectionProp<AgentProps>) => import("../common-types").Collection<Agent, AgentProps>;
+export {};

package/dist/typings/entities/index.d.ts

@@ -1,5 +1,7 @@
 import * as aiAction from './ai-action';
 import * as aiActionInvocation from './ai-action-invocation';
+import * as agent from './agent';
+import * as agentRun from './agent-run';
 import * as apiKey from './api-key';
 import * as appAction from './app-action';
 import * as appActionCall from './app-action-call';
@@ -68,6 +70,8 @@ import * as resource from './resource';
 declare const _default: {
     aiAction: typeof aiAction;
     aiActionInvocation: typeof aiActionInvocation;
+    agent: typeof agent;
+    agentRun: typeof agentRun;
     accessToken: typeof accessToken;
     appAction: typeof appAction;
     appActionCall: typeof appActionCall;