claude-flow
Version:
Enterprise-grade AI agent orchestration with ruv-swarm integration (Alpha Release)
462 lines • 17.1 kB
TypeScript
import * as Core from '@anthropic-ai/sdk/core';
import { APIPromise } from '@anthropic-ai/sdk/core';
import { APIResource } from '@anthropic-ai/sdk/resource';
import * as ToolsMessagesAPI from '@anthropic-ai/sdk/resources/beta/tools/messages';
import * as MessagesAPI from '@anthropic-ai/sdk/resources/messages';
import { Stream } from '@anthropic-ai/sdk/streaming';
export declare class Messages extends APIResource {
/**
* Create a Message.
*
* Send a structured list of input messages with text and/or image content, and the
* model will generate the next message in the conversation.
*
* The Messages API can be used for for either single queries or stateless
* multi-turn conversations.
*/
constructor(body: MessageCreateParamsNonStreaming, options?: Core.RequestOptions): APIPromise<ToolsBetaMessage>;
constructor(body: MessageCreateParamsStreaming, options?: Core.RequestOptions): APIPromise<Stream<MessagesAPI.MessageStreamEvent>>;
constructor(body: MessageCreateParamsBase, options?: Core.RequestOptions): APIPromise<Stream<MessagesAPI.MessageStreamEvent> | ToolsBetaMessage>;
}
export interface Tool {
/**
* [JSON schema](https://json-schema.org/) for this tool's input.
*
* This defines the shape of the `input` that your tool accepts and that the model
* will produce.
*/
input_schema: Tool.InputSchema;
name: string;
/**
* Description of what this tool does.
*
* Tool descriptions should be as detailed as possible. The more information that
* the model has about what the tool is and how to use it, the better it will
* perform. You can use natural language descriptions to reinforce important
* aspects of the tool input JSON schema.
*/
description?: string;
}
export declare namespace Tool {
/**
* [JSON schema](https://json-schema.org/) for this tool's input.
*
* This defines the shape of the `input` that your tool accepts and that the model
* will produce.
*/
interface InputSchema {
type: 'object';
properties?: unknown | null;
[k: string]: unknown;
}
}
export interface ToolResultBlockParam {
tool_use_id: string;
type: 'tool_result';
content?: Array<MessagesAPI.TextBlockParam>;
is_error?: boolean;
}
export interface ToolUseBlock {
id: string;
input: unknown;
name: string;
type: 'tool_use';
}
export interface ToolUseBlockParam {
id: string;
input: unknown;
name: string;
type: 'tool_use';
}
export type ToolsBetaContentBlock = MessagesAPI.TextBlock | ToolUseBlock;
export interface ToolsBetaMessage {
/**
* Unique object identifier.
*
* The format and length of IDs may change over time.
*/
id: string;
/**
* Content generated by the model.
*
* This is an array of content blocks, each of which has a `type` that determines
* its shape. Currently, the only `type` in responses is `"text"`.
*
* Example:
*
* ```json
* [{ "type": "text", "text": "Hi, I'm Claude." }]
* ```
*
* If the request input `messages` ended with an `assistant` turn, then the
* response `content` will continue directly from that last turn. You can use this
* to constrain the model's output.
*
* For example, if the input `messages` were:
*
* ```json
* [
* {
* "role": "user",
* "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun"
* },
* { "role": "assistant", "content": "The best answer is (" }
* ]
* ```
*
* Then the response `content` might be:
*
* ```json
* [{ "type": "text", "text": "B)" }]
* ```
*/
content: Array<ToolsBetaContentBlock>;
/**
* The model that handled the request.
*/
model: string;
/**
* Conversational role of the generated message.
*
* This will always be `"assistant"`.
*/
role: 'assistant';
/**
* The reason that we stopped.
*
* This may be one the following values:
*
* - `"end_turn"`: the model reached a natural stopping point
* - `"max_tokens"`: we exceeded the requested `max_tokens` or the model's maximum
* - `"stop_sequence"`: one of your provided custom `stop_sequences` was generated
* - `"tool_use"`: (tools beta only) the model invoked one or more tools
*
* In non-streaming mode this value is always non-null. In streaming mode, it is
* null in the `message_start` event and non-null otherwise.
*/
stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | null;
/**
* Which custom stop sequence was generated, if any.
*
* This value will be a non-null string if one of your custom stop sequences was
* generated.
*/
stop_sequence: string | null;
/**
* Object type.
*
* For Messages, this is always `"message"`.
*/
type: 'message';
/**
* Billing and rate-limit usage.
*
* Anthropic's API bills and rate-limits by token counts, as tokens represent the
* underlying cost to our systems.
*
* Under the hood, the API transforms requests into a format suitable for the
* model. The model's output then goes through a parsing stage before becoming an
* API response. As a result, the token counts in `usage` will not match one-to-one
* with the exact visible content of an API request or response.
*
* For example, `output_tokens` will be non-zero, even for an empty string response
* from Claude.
*/
usage: MessagesAPI.Usage;
}
export interface ToolsBetaMessageParam {
content: string | Array<MessagesAPI.TextBlockParam | MessagesAPI.ImageBlockParam | ToolUseBlockParam | ToolResultBlockParam>;
role: 'user' | 'assistant';
}
export type MessageCreateParams = MessageCreateParamsNonStreaming | MessageCreateParamsStreaming;
export interface MessageCreateParamsBase {
/**
* The maximum number of tokens to generate before stopping.
*
* Note that our models may stop _before_ reaching this maximum. This parameter
* only specifies the absolute maximum number of tokens to generate.
*
* Different models have different maximum values for this parameter. See
* [models](https://docs.anthropic.com/claude/docs/models-overview) for details.
*/
max_tokens: number;
/**
* Input messages.
*
* Our models are trained to operate on alternating `user` and `assistant`
* conversational turns. When creating a new `Message`, you specify the prior
* conversational turns with the `messages` parameter, and the model then generates
* the next `Message` in the conversation.
*
* Each input message must be an object with a `role` and `content`. You can
* specify a single `user`-role message, or you can include multiple `user` and
* `assistant` messages. The first message must always use the `user` role.
*
* If the final message uses the `assistant` role, the response content will
* continue immediately from the content in that message. This can be used to
* constrain part of the model's response.
*
* Example with a single `user` message:
*
* ```json
* [{ "role": "user", "content": "Hello, Claude" }]
* ```
*
* Example with multiple conversational turns:
*
* ```json
* [
* { "role": "user", "content": "Hello there." },
* { "role": "assistant", "content": "Hi, I'm Claude. How can I help you?" },
* { "role": "user", "content": "Can you explain LLMs in plain English?" }
* ]
* ```
*
* Example with a partially-filled response from Claude:
*
* ```json
* [
* {
* "role": "user",
* "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun"
* },
* { "role": "assistant", "content": "The best answer is (" }
* ]
* ```
*
* Each input message `content` may be either a single `string` or an array of
* content blocks, where each block has a specific `type`. Using a `string` for
* `content` is shorthand for an array of one content block of type `"text"`. The
* following input messages are equivalent:
*
* ```json
* { "role": "user", "content": "Hello, Claude" }
* ```
*
* ```json
* { "role": "user", "content": [{ "type": "text", "text": "Hello, Claude" }] }
* ```
*
* Starting with Claude 3 models, you can also send image content blocks:
*
* ```json
* {
* "role": "user",
* "content": [
* {
* "type": "image",
* "source": {
* "type": "base64",
* "media_type": "image/jpeg",
* "data": "/9j/4AAQSkZJRg..."
* }
* },
* { "type": "text", "text": "What is in this image?" }
* ]
* }
* ```
*
* We currently support the `base64` source type for images, and the `image/jpeg`,
* `image/png`, `image/gif`, and `image/webp` media types.
*
* See [examples](https://docs.anthropic.com/claude/reference/messages-examples)
* for more input examples.
*
* Note that if you want to include a
* [system prompt](https://docs.anthropic.com/claude/docs/system-prompts), you can
* use the top-level `system` parameter — there is no `"system"` role for input
* messages in the Messages API.
*/
messages: Array<ToolsBetaMessageParam>;
/**
* The model that will complete your prompt.
*
* See [models](https://docs.anthropic.com/claude/docs/models-overview) for
* additional details and options.
*/
model: string;
/**
* An object describing metadata about the request.
*/
metadata?: MessageCreateParams.Metadata;
/**
* Custom text sequences that will cause the model to stop generating.
*
* Our models will normally stop when they have naturally completed their turn,
* which will result in a response `stop_reason` of `"end_turn"`.
*
* If you want the model to stop generating when it encounters custom strings of
* text, you can use the `stop_sequences` parameter. If the model encounters one of
* the custom sequences, the response `stop_reason` value will be `"stop_sequence"`
* and the response `stop_sequence` value will contain the matched stop sequence.
*/
stop_sequences?: Array<string>;
/**
* Whether to incrementally stream the response using server-sent events.
*
* See [streaming](https://docs.anthropic.com/claude/reference/messages-streaming)
* for details.
*/
stream?: boolean;
/**
* System prompt.
*
* A system prompt is a way of providing context and instructions to Claude, such
* as specifying a particular goal or role. See our
* [guide to system prompts](https://docs.anthropic.com/claude/docs/system-prompts).
*/
system?: string;
/**
* Amount of randomness injected into the response.
*
* Defaults to `1.0`. Ranges from `0.0` to `1.0`. Use `temperature` closer to `0.0`
* for analytical / multiple choice, and closer to `1.0` for creative and
* generative tasks.
*
* Note that even with `temperature` of `0.0`, the results will not be fully
* deterministic.
*/
temperature?: number;
/**
* [beta] Definitions of tools that the model may use.
*
* If you include `tools` in your API request, the model may return `tool_use`
* content blocks that represent the model's use of those tools. You can then run
* those tools using the tool input generated by the model and then optionally
* return results back to the model using `tool_result` content blocks.
*
* Each tool definition includes:
*
* - `name`: Name of the tool.
* - `description`: Optional, but strongly-recommended description of the tool.
* - `input_schema`: [JSON schema](https://json-schema.org/) for the tool `input`
* shape that the model will produce in `tool_use` output content blocks.
*
* For example, if you defined `tools` as:
*
* ```json
* [
* {
* "name": "get_stock_price",
* "description": "Get the current stock price for a given ticker symbol.",
* "input_schema": {
* "type": "object",
* "properties": {
* "ticker": {
* "type": "string",
* "description": "The stock ticker symbol, e.g. AAPL for Apple Inc."
* }
* },
* "required": ["ticker"]
* }
* }
* ]
* ```
*
* And then asked the model "What's the S&P 500 at today?", the model might produce
* `tool_use` content blocks in the response like this:
*
* ```json
* [
* {
* "type": "tool_use",
* "id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV",
* "name": "get_stock_price",
* "input": { "ticker": "^GSPC" }
* }
* ]
* ```
*
* You might then run your `get_stock_price` tool with `{"ticker": "^GSPC"}` as an
* input, and return the following back to the model in a subsequent `user`
* message:
*
* ```json
* [
* {
* "type": "tool_result",
* "tool_use_id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV",
* "content": "259.75 USD"
* }
* ]
* ```
*
* Tools can be used for workflows that include running client-side tools and
* functions, or more generally whenever you want the model to produce a particular
* JSON structure of output.
*
* See our [beta guide](https://docs.anthropic.com/claude/docs/tool-use) for more
* details.
*/
tools?: Array<Tool>;
/**
* Only sample from the top K options for each subsequent token.
*
* Used to remove "long tail" low probability responses.
* [Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
*
* Recommended for advanced use cases only. You usually only need to use
* `temperature`.
*/
top_k?: number;
/**
* Use nucleus sampling.
*
* In nucleus sampling, we compute the cumulative distribution over all the options
* for each subsequent token in decreasing probability order and cut it off once it
* reaches a particular probability specified by `top_p`. You should either alter
* `temperature` or `top_p`, but not both.
*
* Recommended for advanced use cases only. You usually only need to use
* `temperature`.
*/
top_p?: number;
}
export declare namespace MessageCreateParams {
/**
* An object describing metadata about the request.
*/
interface Metadata {
/**
* An external identifier for the user who is associated with the request.
*
* This should be a uuid, hash value, or other opaque identifier. Anthropic may use
* this id to help detect abuse. Do not include any identifying information such as
* name, email address, or phone number.
*/
user_id?: string | null;
}
type MessageCreateParamsNonStreaming = ToolsMessagesAPI.MessageCreateParamsNonStreaming;
type MessageCreateParamsStreaming = ToolsMessagesAPI.MessageCreateParamsStreaming;
}
export interface MessageCreateParamsNonStreaming extends MessageCreateParamsBase {
/**
* Whether to incrementally stream the response using server-sent events.
*
* See [streaming](https://docs.anthropic.com/claude/reference/messages-streaming)
* for details.
*/
stream?: false;
}
export interface MessageCreateParamsStreaming extends MessageCreateParamsBase {
/**
* Whether to incrementally stream the response using server-sent events.
*
* See [streaming](https://docs.anthropic.com/claude/reference/messages-streaming)
* for details.
*/
stream: true;
}
export declare namespace Messages {
export import Tool = ToolsMessagesAPI.Tool;
export import ToolResultBlockParam = ToolsMessagesAPI.ToolResultBlockParam;
export import ToolUseBlock = ToolsMessagesAPI.ToolUseBlock;
export import ToolUseBlockParam = ToolsMessagesAPI.ToolUseBlockParam;
export import ToolsBetaContentBlock = ToolsMessagesAPI.ToolsBetaContentBlock;
export import ToolsBetaMessage = ToolsMessagesAPI.ToolsBetaMessage;
export import ToolsBetaMessageParam = ToolsMessagesAPI.ToolsBetaMessageParam;
export import MessageCreateParams = ToolsMessagesAPI.MessageCreateParams;
export import MessageCreateParamsNonStreaming = ToolsMessagesAPI.MessageCreateParamsNonStreaming;
export import MessageCreateParamsStreaming = ToolsMessagesAPI.MessageCreateParamsStreaming;
}
//# sourceMappingURL=messages.d.ts.map