@ideascol/agents-generator-sdk 0.7.4 → 0.8.0

package/dist/lib/index.d.ts

@@ -1,21 +1,47 @@
-import { ApiError, CancelablePromise, CancelError, ConversationsService, MessageCreate, OpenAPI, AgentService, McpServersService, RootService, FileLibraryService, CredentialsService, AdminAgentsService, PublicAgentsService, PublicConversationsService, AdminConversationsService, AdminCredentialsService, AdminFileLibraryService, AdminMcpServersService, AdminWorkspacesService, WorkspaceCollaboratorsService, AdminApiKeysService, PresenceService, ModelsService, SchemaGeneratorService, TokenUsageService, AuthService } from "./clients/agents-generator";
+import { ApiError, CancelablePromise, CancelError, ConversationsService, MessageCreate, OpenAPI, AgentService, McpServersService, RootService, FileLibraryService, CredentialsService, AdminAgentsService, PublicAgentsService, PublicConversationsService, AdminConversationsService, AdminCredentialsService, AdminFileLibraryService, AdminMcpServersService, AdminWorkspacesService, WorkspaceCollaboratorsService, AdminApiKeysService, PresenceService, ModelsService, SchemaGeneratorService, TokenUsageService, AuthService, type AgentRequest, type CreateAgentResponse, type Handoff, type MCPServerReference } from "./clients/agents-generator";
 export * from "./clients/agents-generator";
-export interface StreamEvent {
-    type: string;
-    content?: string;
-    message_id?: string;
-    transfer?: TransferEvent;
-}
+export { type ModelProvider, type ModelName, type ModelInfo, MODEL_PROVIDERS, MODEL_NAMES, MODELS_BY_PROVIDER, MODEL_INFO, } from "./generated/models";
+import type { ModelName, ModelProvider } from "./generated/models";
 export interface TransferEvent {
     from_agent?: string;
     to_agent?: string;
     reason?: string;
 }
+export interface MessageStreamEvent {
+    type: "message";
+    content?: string;
+}
+export interface DoneStreamEvent {
+    type: "done";
+    message_id?: string;
+}
+export interface TransferStreamEvent {
+    type: "transfer";
+    transfer?: TransferEvent;
+}
+export interface ToolCallEvent {
+    type: "tool_call";
+    call_id: string;
+    name: string;
+    arguments?: unknown;
+    raw_arguments?: string;
+}
+export interface ToolResultAckEvent {
+    type: "tool_result_ack";
+    ack?: Record<string, any>;
+}
+export interface UnknownStreamEvent {
+    type: string;
+    [key: string]: any;
+}
+export type StreamEvent = MessageStreamEvent | DoneStreamEvent | TransferStreamEvent | ToolCallEvent | ToolResultAckEvent | UnknownStreamEvent;
 export interface StreamCallbacks {
     onMessage?: (content: string) => void;
     onDone?: (messageId: string) => void;
     onError?: (error: Error) => void;
     onTransfer?: (transfer: TransferEvent) => void;
+    onToolCall?: (toolCall: ToolCallEvent) => void;
+    onToolResultAck?: (ack: Record<string, any>) => void;
 }
 export interface SendMessageResponse {
     status: string;
@@ -23,8 +49,121 @@ export interface SendMessageResponse {
     message_id?: string;
     transfers?: TransferEvent[];
 }
+export type LocalFunctionSchema = Record<string, any>;
+export interface LocalFunctionContext {
+    agentId?: string;
+    conversationId: string;
+    callId: string;
+    client: AgentClient;
+}
+export interface LocalFunctionDefinition {
+    name: string;
+    description: string;
+    parameters?: LocalFunctionSchema;
+    headers?: Record<string, string> | null;
+    execute: (args: unknown, context: LocalFunctionContext) => unknown | Promise<unknown>;
+}
+export interface AgentFacadeOptions {
+    name: string;
+    description?: string | null;
+    instructions?: string | null;
+    functions?: Array<LocalFunctionDefinition>;
+    workspaceId?: string | null;
+    credentialId?: string | null;
+    folderId?: string | null;
+    handoffs?: Array<Handoff>;
+    mcpServers?: Array<MCPServerReference>;
+    outputSchema?: Record<string, any> | null;
+    modelProvider?: ModelProvider | (string & {}) | null;
+    modelName?: ModelName | (string & {}) | null;
+    baseUrl?: string | null;
+    nodeCredentialId?: string | null;
+    maxTokens?: number | null;
+    reasoningEffort?: string | null;
+}
+export interface InlineMessage {
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    name?: string;
+    tool_call_id?: string;
+}
+export interface InlineRunOptions {
+    history?: Array<InlineMessage>;
+    metadata?: Record<string, any> | null;
+    signal?: AbortSignal;
+    /**
+     * SSE streaming callbacks. Fire as the model emits content. The returned
+     * promise still resolves with the final `InlineRunResult` after the stream
+     * (and any callback-tool round-trips) complete.
+     */
+    callbacks?: SendWithToolsCallbacks;
+}
+export interface InlineRunResult {
+    message: string;
+    message_id?: string;
+    tool_results?: Array<ToolExecutionResult>;
+    transfers?: Array<TransferEvent>;
+    token_usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+        total_tokens?: number;
+    };
+}
+export interface InlineAgentDefinition extends AgentFacadeOptions {
+    /** Inline credential override; transient — never persisted server-side. */
+    apiKey?: string | null;
+    /** Cap on callback-tool round-trips per `run` call. Default: 10. */
+    maxToolIterations?: number;
+}
+export interface EphemeralConversationOptions {
+    title?: string | null;
+    ttlSeconds?: number;
+}
+export interface EphemeralConversationHandle {
+    conversation_id: string;
+    agent_id: string;
+    expires_at: string;
+    send(input: string, callbacks?: SendWithToolsCallbacks): Promise<SendWithToolsResponse>;
+    close(): Promise<void>;
+}
+export interface InlineAgentHandle {
+    /** Frozen wire payload — useful for debugging or audit. */
+    definition: AgentRequest;
+    run(input: string, opts?: InlineRunOptions): Promise<InlineRunResult>;
+    /**
+     * SSE streaming variant. Yields raw `StreamEvent`s as they arrive (one
+     * `message` event per accumulated delta, plus `tool_call`, `transfer`,
+     * `done`). Tool-callback round-trips are handled internally — the
+     * iterator continues across them transparently.
+     */
+    runStream(input: string, opts?: InlineRunOptions): AsyncIterable<StreamEvent>;
+    startConversation(opts?: EphemeralConversationOptions): Promise<EphemeralConversationHandle>;
+}
+export interface ToolExecutionResult {
+    call_id: string;
+    name: string;
+    result?: unknown;
+    error?: string;
+    is_error: boolean;
+}
+export interface SendWithToolsCallbacks extends StreamCallbacks {
+    onToolResult?: (result: ToolExecutionResult) => void;
+}
+export interface SendWithToolsOptions {
+    content: string;
+    agentId?: string;
+    conversationId?: string;
+    title?: string | null;
+    functions?: Array<LocalFunctionDefinition>;
+    useDraft?: boolean;
+    metadata?: Record<string, any> | null;
+    callbacks?: SendWithToolsCallbacks;
+}
+export interface SendWithToolsResponse extends SendMessageResponse {
+    conversation_id: string;
+    tool_results?: Array<ToolExecutionResult>;
+}
 declare class ConversationsServiceStream extends ConversationsService {
-    constructor();
     /**
      * Add Message with SSE streaming support
      * @param conversationId The ID of the conversation
@@ -91,13 +230,51 @@ export declare class AgentClient {
     OpenAPI: typeof OpenAPI;
     /**
      * Conversations stream service
-    * @deprecated Use client.public.conversations.sendMessageWithStreaming instead
+     * @deprecated Use client.public.conversations.sendMessageWithStreaming instead
      */
     conversationsStream: typeof ConversationsServiceStream;
+    private localFunctionRegistry;
     constructor({ apiUrl, apiToken, }: {
         apiUrl: string;
-        apiToken: string;
+        /**
+         * Platform auth token: a Keycloak JWT or a workspace API key (`ack_*`).
+         * Optional — omit it for anonymous inline-agent runs where you bring
+         * your own model-provider key via `defineAgent({ apiKey })`. Anonymous
+         * callers cannot use workspace-scoped features (credential refs, stored
+         * agents, workspace-agent tools).
+         */
+        apiToken?: string;
     });
+    defineFunction(definition: LocalFunctionDefinition): LocalFunctionDefinition;
+    createAgent(options: AgentFacadeOptions): Promise<CreateAgentResponse>;
+    updateAgent(agentId: string, options: AgentFacadeOptions): Promise<Record<string, any>>;
+    /**
+     * Define an agent in code and execute it without persisting the
+     * configuration server-side. Genkit-style usage:
+     *
+     * ```ts
+     * const agent = client.defineAgent({
+     *   name: "weather",
+     *   instructions: "...",
+     *   modelProvider: "openai",
+     *   modelName: "gpt-5-mini",
+     *   apiKey: process.env.OPENAI_KEY,
+     *   functions: [...],
+     * });
+     * const r = await agent.run("Weather in Bogota?");
+     * ```
+     *
+     * For multi-turn sessions where you don't want to replay history each
+     * call, use `agent.startConversation()`.
+     */
+    defineAgent(definition: InlineAgentDefinition): InlineAgentHandle;
+    /** Internal: register inline functions for an ephemeral agent id. */
+    private registerLocalFunctions;
+    /** Internal: drop inline functions when an ephemeral conversation closes. */
+    private unregisterLocalFunctions;
+    private streamConversationTurn;
+    private resolveConversationContext;
+    private executeToolCall;
     /**
      * sendMessageWithStreaming: Sent a message with streaming support to a conversation
      * Use client.public.conversations.sendMessageWithStreaming instead
@@ -110,5 +287,6 @@ export declare class AgentClient {
      * Use client.public.conversations.sendMessage instead
      */
     sendMessage(conversationId: string, requestBody: MessageCreate): Promise<SendMessageResponse>;
+    sendWithTools(options: SendWithToolsOptions): Promise<SendWithToolsResponse>;
 }
 export default AgentClient;

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@ideascol/agents-generator-sdk",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "main": "dist/index.js",
   "scripts": {
     "test": "bun test",
     "build": "tsc --emitDeclarationOnly && bun build ./src/index.ts ./src/bin/cli.ts --target=node --outdir ./dist --format cjs",
     "build:test": "bun build ./src/tests/*.ts --target=node --outdir dist/tests --format cjs",
+    "generate:models": "bun run scripts/generate-models.ts",
     "prepublishOnly": "bun run build",
     "start": "bun run src/cli.ts"
   },