echo-ai-sdk-ts 2.5.0 → 2.6.0

package/dist/index.js

@@ -36,6 +36,10 @@ __export(index_exports, {
   AgentIterationLimitError: () => AgentIterationLimitError,
   AgentPipeline: () => AgentPipeline,
   AgentRouter: () => AgentRouter,
+  AwsBedrockProvider: () => AwsBedrockProvider,
+  AwsSageMakerDeployer: () => AwsSageMakerDeployer,
+  AzureMlDeployer: () => AzureMlDeployer,
+  AzureOpenAiProvider: () => AzureOpenAiProvider,
   BaseProvider: () => BaseProvider,
   BaseSTTProvider: () => BaseSTTProvider,
   BaseSpeakerRecognizer: () => BaseSpeakerRecognizer,
@@ -53,9 +57,10 @@ __export(index_exports, {
   DEFAULT_REDACTION_RULES: () => DEFAULT_REDACTION_RULES,
   EchoAI: () => EchoAI,
   EchoVoice: () => EchoVoice,
-  ExperimentManager: () => ExperimentManager,
   FileSessionStore: () => FileSessionStore,
   GatewayRoutingError: () => GatewayRoutingError,
+  GcpVertexManager: () => GcpVertexManager,
+  GcpVertexProvider: () => GcpVertexProvider,
   HandoffManager: () => HandoffManager,
   HuggingFaceImageGen: () => HuggingFaceImageGen,
   HuggingFaceTTS: () => HuggingFaceTTS,
@@ -14265,6 +14270,384 @@ var InferenceEndpointManager = class {
     if (!res.ok) throw new Error("Failed to resume endpoint");
   }
 };
+
+// src/deployment/aws_sagemaker.ts
+var import_client_sagemaker = require("@aws-sdk/client-sagemaker");
+var AwsSageMakerDeployer = class {
+  client;
+  constructor(config) {
+    this.client = new import_client_sagemaker.SageMakerClient({
+      region: config.region,
+      credentials: config.credentials
+    });
+  }
+  /**
+   * Orchestrates the 3-step SageMaker deployment process.
+   */
+  async deployEndpoint(params) {
+    const configName = `${params.modelName}-config-${Date.now()}`;
+    const endpointName = `${params.modelName}-endpoint`;
+    try {
+      await this.client.send(new import_client_sagemaker.CreateModelCommand({
+        ModelName: params.modelName,
+        PrimaryContainer: {
+          Image: params.primaryContainerImage,
+          ModelDataUrl: params.modelDataUrl,
+          Environment: {
+            // HF specific deployment variables if using Hugging Face DLC
+            "HF_MODEL_ID": params.modelName,
+            "HF_TASK": "text-generation"
+          }
+        },
+        ExecutionRoleArn: params.executionRoleArn
+      }));
+      await this.client.send(new import_client_sagemaker.CreateEndpointConfigCommand({
+        EndpointConfigName: configName,
+        ProductionVariants: [{
+          VariantName: "AllTraffic",
+          ModelName: params.modelName,
+          InitialInstanceCount: params.initialInstanceCount || 1,
+          InstanceType: params.instanceType || "ml.g5.xlarge"
+        }]
+      }));
+      await this.client.send(new import_client_sagemaker.CreateEndpointCommand({
+        EndpointName: endpointName,
+        EndpointConfigName: configName
+      }));
+      return endpointName;
+    } catch (e) {
+      throw new Error(`AWS SageMaker deployment failed: ${e.message}`);
+    }
+  }
+  /**
+   * Checks the provisioning status of a SageMaker Endpoint.
+   */
+  async getEndpointStatus(endpointName) {
+    const res = await this.client.send(new import_client_sagemaker.DescribeEndpointCommand({ EndpointName: endpointName }));
+    return res.EndpointStatus || "Unknown";
+  }
+};
+
+// src/deployment/gcp_vertex_manager.ts
+var import_aiplatform = require("@google-cloud/aiplatform");
+var GcpVertexManager = class {
+  client;
+  project;
+  location;
+  constructor(config) {
+    this.client = new import_aiplatform.EndpointServiceClient({
+      apiEndpoint: `${config.location}-aiplatform.googleapis.com`
+    });
+    this.project = config.project;
+    this.location = config.location;
+  }
+  /**
+   * Deploys an uploaded Vertex AI Model Resource to a newly created Endpoint.
+   */
+  async deployModel(params) {
+    const parent = `projects/${this.project}/locations/${this.location}`;
+    const [endpointLro] = await this.client.createEndpoint({
+      parent,
+      endpoint: { displayName: `${params.displayName}-endpoint` }
+    });
+    const [endpointResponse] = await endpointLro.promise();
+    const endpointName = endpointResponse.name;
+    const [deployLro] = await this.client.deployModel({
+      endpoint: endpointName,
+      deployedModel: {
+        model: params.modelName,
+        displayName: `${params.displayName}-deployment`,
+        dedicatedResources: {
+          machineSpec: {
+            machineType: params.machineType || "n1-standard-4",
+            acceleratorType: params.acceleratorType || void 0,
+            acceleratorCount: params.acceleratorCount || 0
+          },
+          minReplicaCount: 1,
+          maxReplicaCount: 1
+        }
+      }
+    });
+    console.log("Waiting for Vertex AI deployment LRO to finish...");
+    await deployLro.promise();
+    return endpointName;
+  }
+};
+
+// src/deployment/azure_ml.ts
+var import_arm_machinelearning = require("@azure/arm-machinelearning");
+var import_identity = require("@azure/identity");
+var AzureMlDeployer = class {
+  client;
+  config;
+  constructor(config) {
+    const credential = new import_identity.DefaultAzureCredential();
+    this.client = new import_arm_machinelearning.AzureMachineLearningServicesManagementClient(credential, config.subscriptionId);
+    this.config = config;
+  }
+  /**
+   * Orchestrates the creation of an Azure Managed Online Endpoint and Deployment.
+   */
+  async deployEndpoint(params) {
+    const { resourceGroupName, workspaceName } = this.config;
+    try {
+      const endpointLro = await this.client.onlineEndpoints.beginCreateOrUpdateAndWait(
+        resourceGroupName,
+        workspaceName,
+        params.endpointName,
+        {
+          location: "eastus",
+          // Would ideally be dynamic based on workspace location
+          properties: {
+            authMode: "Key",
+            compute: "Managed"
+          }
+        }
+      );
+      await this.client.onlineDeployments.beginCreateOrUpdateAndWait(
+        resourceGroupName,
+        workspaceName,
+        params.endpointName,
+        params.deploymentName,
+        {
+          location: endpointLro.location,
+          properties: {
+            endpointComputeType: "Managed",
+            model: params.modelId,
+            instanceType: params.instanceType || "Standard_DS3_v2",
+            scaleSettings: {
+              scaleType: "Default",
+              instanceCount: Math.max(1, params.instanceCount || 1)
+            }
+          }
+        }
+      );
+      await this.client.onlineEndpoints.beginCreateOrUpdateAndWait(
+        resourceGroupName,
+        workspaceName,
+        params.endpointName,
+        {
+          location: endpointLro.location,
+          properties: {
+            authMode: "Key",
+            compute: "Managed",
+            traffic: {
+              [params.deploymentName]: 100
+            }
+          }
+        }
+      );
+      return params.endpointName;
+    } catch (e) {
+      throw new Error(`Azure ML Deployment failed: ${e.message}`);
+    }
+  }
+  /**
+   * Retrieves the current provisioning state of an Azure ML Endpoint.
+   */
+  async getEndpointStatus(endpointName) {
+    const endpoint = await this.client.onlineEndpoints.get(
+      this.config.resourceGroupName,
+      this.config.workspaceName,
+      endpointName
+    );
+    return endpoint.properties?.provisioningState || "Unknown";
+  }
+};
+
+// src/models/aws_bedrock.ts
+var import_client_bedrock_runtime = require("@aws-sdk/client-bedrock-runtime");
+var AwsBedrockProvider = class extends BaseProvider {
+  client;
+  defaultModel;
+  constructor(config) {
+    super();
+    this.client = new import_client_bedrock_runtime.BedrockRuntimeClient({
+      region: config.region,
+      credentials: config.credentials
+    });
+    this.defaultModel = config.defaultModel || "anthropic.claude-3-haiku-20240307-v1:0";
+  }
+  get providerName() {
+    return "aws_bedrock";
+  }
+  async chatComplete(request) {
+    const modelId = request.model_family === "smart" ? "anthropic.claude-3-sonnet-20240229-v1:0" : this.defaultModel;
+    const systemMessage = request.messages.find((m) => m.role === "system")?.content || "";
+    const userMessages = request.messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role,
+      content: [{ type: "text", text: m.content }]
+    }));
+    const payload = {
+      anthropic_version: "bedrock-2023-05-31",
+      max_tokens: request.max_tokens || 1024,
+      system: systemMessage,
+      messages: userMessages,
+      temperature: request.temperature || 0.7
+    };
+    try {
+      const command = new import_client_bedrock_runtime.InvokeModelCommand({
+        modelId,
+        contentType: "application/json",
+        accept: "application/json",
+        body: JSON.stringify(payload)
+      });
+      const response = await this.client.send(command);
+      const responseBody = JSON.parse(new TextDecoder().decode(response.body));
+      return {
+        content: responseBody.content?.[0]?.text || null,
+        usage: {
+          prompt_tokens: responseBody.usage?.input_tokens || 0,
+          completion_tokens: responseBody.usage?.output_tokens || 0,
+          total_tokens: (responseBody.usage?.input_tokens || 0) + (responseBody.usage?.output_tokens || 0)
+        },
+        provider_name: this.providerName,
+        model_name: modelId
+      };
+    } catch (e) {
+      throw new Error(`AWS Bedrock invocation failed: ${e.message}`);
+    }
+  }
+  async *chatStream(request) {
+    const res = await this.chatComplete(request);
+    if (res.content) {
+      yield res.content;
+    }
+  }
+};
+
+// src/models/gcp_vertex.ts
+var import_vertexai = require("@google-cloud/vertexai");
+var GcpVertexProvider = class extends BaseProvider {
+  client;
+  defaultModel;
+  constructor(config) {
+    super();
+    this.client = new import_vertexai.VertexAI({ project: config.project, location: config.location });
+    this.defaultModel = config.defaultModel || "gemini-1.5-flash-preview-0409";
+  }
+  get providerName() {
+    return "gcp_vertex";
+  }
+  async chatComplete(request) {
+    const model = request.model_family === "smart" ? "gemini-1.5-pro-preview-0409" : this.defaultModel;
+    const generativeModel = this.client.getGenerativeModel({
+      model,
+      generationConfig: {
+        maxOutputTokens: request.max_tokens || 1024,
+        temperature: request.temperature || 0.7
+      }
+    });
+    const systemInstruction = request.messages.find((m) => m.role === "system")?.content || void 0;
+    const contents = request.messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    try {
+      const response = await generativeModel.generateContent({
+        contents,
+        systemInstruction: systemInstruction ? { role: "system", parts: [{ text: systemInstruction }] } : void 0
+      });
+      const responseText = response.response.candidates?.[0]?.content?.parts?.[0]?.text || null;
+      return {
+        content: responseText,
+        usage: {
+          prompt_tokens: response.response.usageMetadata?.promptTokenCount || 0,
+          completion_tokens: response.response.usageMetadata?.candidatesTokenCount || 0,
+          total_tokens: response.response.usageMetadata?.totalTokenCount || 0
+        },
+        provider_name: this.providerName,
+        model_name: model
+      };
+    } catch (e) {
+      throw new Error(`GCP Vertex invocation failed: ${e.message}`);
+    }
+  }
+  async *chatStream(request) {
+    const model = request.model_family === "smart" ? "gemini-1.5-pro-preview-0409" : this.defaultModel;
+    const generativeModel = this.client.getGenerativeModel({ model });
+    const contents = request.messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    const stream = await generativeModel.generateContentStream({ contents });
+    for await (const chunk of stream.stream) {
+      if (chunk.candidates?.[0]?.content?.parts?.[0]?.text) {
+        yield chunk.candidates[0].content.parts[0].text;
+      }
+    }
+  }
+};
+
+// src/models/azure_openai.ts
+var import_openai6 = require("@azure/openai");
+var AzureOpenAiProvider = class extends BaseProvider {
+  client;
+  deploymentName;
+  constructor(config) {
+    super();
+    this.client = new import_openai6.OpenAIClient(config.endpoint, new import_openai6.AzureKeyCredential(config.apiKey));
+    this.deploymentName = config.deploymentName || "gpt-35-turbo";
+  }
+  get providerName() {
+    return "azure_openai";
+  }
+  async chatComplete(request) {
+    try {
+      const response = await this.client.getChatCompletions(
+        this.deploymentName,
+        request.messages.map((m) => ({
+          role: m.role,
+          content: m.content
+        })),
+        {
+          maxTokens: request.max_tokens || 1024,
+          temperature: request.temperature || 0.7
+        }
+      );
+      const message = response.choices[0].message;
+      return {
+        content: message?.content || null,
+        tool_calls: message?.toolCalls ? message.toolCalls.map((tc) => ({
+          id: tc.id,
+          function: {
+            name: tc.function?.name,
+            arguments: tc.function?.arguments
+          }
+        })) : void 0,
+        usage: {
+          prompt_tokens: response.usage?.promptTokens || 0,
+          completion_tokens: response.usage?.completionTokens || 0,
+          total_tokens: response.usage?.totalTokens || 0
+        },
+        provider_name: this.providerName,
+        model_name: this.deploymentName
+      };
+    } catch (e) {
+      throw new Error(`Azure OpenAI invocation failed: ${e.message}`);
+    }
+  }
+  async *chatStream(request) {
+    const stream = await this.client.streamChatCompletions(
+      this.deploymentName,
+      request.messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      {
+        maxTokens: request.max_tokens || 1024,
+        temperature: request.temperature || 0.7
+      }
+    );
+    for await (const chunk of stream) {
+      for (const choice of chunk.choices) {
+        if (choice.delta?.content) {
+          yield choice.delta.content;
+        }
+      }
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AIModelGateway,
@@ -14273,6 +14656,10 @@ var InferenceEndpointManager = class {
   AgentIterationLimitError,
   AgentPipeline,
   AgentRouter,
+  AwsBedrockProvider,
+  AwsSageMakerDeployer,
+  AzureMlDeployer,
+  AzureOpenAiProvider,
   BaseProvider,
   BaseSTTProvider,
   BaseSpeakerRecognizer,
@@ -14290,9 +14677,10 @@ var InferenceEndpointManager = class {
   DEFAULT_REDACTION_RULES,
   EchoAI,
   EchoVoice,
-  ExperimentManager,
   FileSessionStore,
   GatewayRoutingError,
+  GcpVertexManager,
+  GcpVertexProvider,
   HandoffManager,
   HuggingFaceImageGen,
   HuggingFaceTTS,

package/dist/index.mjs

@@ -14177,6 +14177,384 @@ var InferenceEndpointManager = class {
     if (!res.ok) throw new Error("Failed to resume endpoint");
   }
 };
+
+// src/deployment/aws_sagemaker.ts
+import { SageMakerClient, CreateModelCommand, CreateEndpointConfigCommand, CreateEndpointCommand, DescribeEndpointCommand } from "@aws-sdk/client-sagemaker";
+var AwsSageMakerDeployer = class {
+  client;
+  constructor(config) {
+    this.client = new SageMakerClient({
+      region: config.region,
+      credentials: config.credentials
+    });
+  }
+  /**
+   * Orchestrates the 3-step SageMaker deployment process.
+   */
+  async deployEndpoint(params) {
+    const configName = `${params.modelName}-config-${Date.now()}`;
+    const endpointName = `${params.modelName}-endpoint`;
+    try {
+      await this.client.send(new CreateModelCommand({
+        ModelName: params.modelName,
+        PrimaryContainer: {
+          Image: params.primaryContainerImage,
+          ModelDataUrl: params.modelDataUrl,
+          Environment: {
+            // HF specific deployment variables if using Hugging Face DLC
+            "HF_MODEL_ID": params.modelName,
+            "HF_TASK": "text-generation"
+          }
+        },
+        ExecutionRoleArn: params.executionRoleArn
+      }));
+      await this.client.send(new CreateEndpointConfigCommand({
+        EndpointConfigName: configName,
+        ProductionVariants: [{
+          VariantName: "AllTraffic",
+          ModelName: params.modelName,
+          InitialInstanceCount: params.initialInstanceCount || 1,
+          InstanceType: params.instanceType || "ml.g5.xlarge"
+        }]
+      }));
+      await this.client.send(new CreateEndpointCommand({
+        EndpointName: endpointName,
+        EndpointConfigName: configName
+      }));
+      return endpointName;
+    } catch (e) {
+      throw new Error(`AWS SageMaker deployment failed: ${e.message}`);
+    }
+  }
+  /**
+   * Checks the provisioning status of a SageMaker Endpoint.
+   */
+  async getEndpointStatus(endpointName) {
+    const res = await this.client.send(new DescribeEndpointCommand({ EndpointName: endpointName }));
+    return res.EndpointStatus || "Unknown";
+  }
+};
+
+// src/deployment/gcp_vertex_manager.ts
+import { EndpointServiceClient } from "@google-cloud/aiplatform";
+var GcpVertexManager = class {
+  client;
+  project;
+  location;
+  constructor(config) {
+    this.client = new EndpointServiceClient({
+      apiEndpoint: `${config.location}-aiplatform.googleapis.com`
+    });
+    this.project = config.project;
+    this.location = config.location;
+  }
+  /**
+   * Deploys an uploaded Vertex AI Model Resource to a newly created Endpoint.
+   */
+  async deployModel(params) {
+    const parent = `projects/${this.project}/locations/${this.location}`;
+    const [endpointLro] = await this.client.createEndpoint({
+      parent,
+      endpoint: { displayName: `${params.displayName}-endpoint` }
+    });
+    const [endpointResponse] = await endpointLro.promise();
+    const endpointName = endpointResponse.name;
+    const [deployLro] = await this.client.deployModel({
+      endpoint: endpointName,
+      deployedModel: {
+        model: params.modelName,
+        displayName: `${params.displayName}-deployment`,
+        dedicatedResources: {
+          machineSpec: {
+            machineType: params.machineType || "n1-standard-4",
+            acceleratorType: params.acceleratorType || void 0,
+            acceleratorCount: params.acceleratorCount || 0
+          },
+          minReplicaCount: 1,
+          maxReplicaCount: 1
+        }
+      }
+    });
+    console.log("Waiting for Vertex AI deployment LRO to finish...");
+    await deployLro.promise();
+    return endpointName;
+  }
+};
+
+// src/deployment/azure_ml.ts
+import { AzureMachineLearningServicesManagementClient } from "@azure/arm-machinelearning";
+import { DefaultAzureCredential } from "@azure/identity";
+var AzureMlDeployer = class {
+  client;
+  config;
+  constructor(config) {
+    const credential = new DefaultAzureCredential();
+    this.client = new AzureMachineLearningServicesManagementClient(credential, config.subscriptionId);
+    this.config = config;
+  }
+  /**
+   * Orchestrates the creation of an Azure Managed Online Endpoint and Deployment.
+   */
+  async deployEndpoint(params) {
+    const { resourceGroupName, workspaceName } = this.config;
+    try {
+      const endpointLro = await this.client.onlineEndpoints.beginCreateOrUpdateAndWait(
+        resourceGroupName,
+        workspaceName,
+        params.endpointName,
+        {
+          location: "eastus",
+          // Would ideally be dynamic based on workspace location
+          properties: {
+            authMode: "Key",
+            compute: "Managed"
+          }
+        }
+      );
+      await this.client.onlineDeployments.beginCreateOrUpdateAndWait(
+        resourceGroupName,
+        workspaceName,
+        params.endpointName,
+        params.deploymentName,
+        {
+          location: endpointLro.location,
+          properties: {
+            endpointComputeType: "Managed",
+            model: params.modelId,
+            instanceType: params.instanceType || "Standard_DS3_v2",
+            scaleSettings: {
+              scaleType: "Default",
+              instanceCount: Math.max(1, params.instanceCount || 1)
+            }
+          }
+        }
+      );
+      await this.client.onlineEndpoints.beginCreateOrUpdateAndWait(
+        resourceGroupName,
+        workspaceName,
+        params.endpointName,
+        {
+          location: endpointLro.location,
+          properties: {
+            authMode: "Key",
+            compute: "Managed",
+            traffic: {
+              [params.deploymentName]: 100
+            }
+          }
+        }
+      );
+      return params.endpointName;
+    } catch (e) {
+      throw new Error(`Azure ML Deployment failed: ${e.message}`);
+    }
+  }
+  /**
+   * Retrieves the current provisioning state of an Azure ML Endpoint.
+   */
+  async getEndpointStatus(endpointName) {
+    const endpoint = await this.client.onlineEndpoints.get(
+      this.config.resourceGroupName,
+      this.config.workspaceName,
+      endpointName
+    );
+    return endpoint.properties?.provisioningState || "Unknown";
+  }
+};
+
+// src/models/aws_bedrock.ts
+import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
+var AwsBedrockProvider = class extends BaseProvider {
+  client;
+  defaultModel;
+  constructor(config) {
+    super();
+    this.client = new BedrockRuntimeClient({
+      region: config.region,
+      credentials: config.credentials
+    });
+    this.defaultModel = config.defaultModel || "anthropic.claude-3-haiku-20240307-v1:0";
+  }
+  get providerName() {
+    return "aws_bedrock";
+  }
+  async chatComplete(request) {
+    const modelId = request.model_family === "smart" ? "anthropic.claude-3-sonnet-20240229-v1:0" : this.defaultModel;
+    const systemMessage = request.messages.find((m) => m.role === "system")?.content || "";
+    const userMessages = request.messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role,
+      content: [{ type: "text", text: m.content }]
+    }));
+    const payload = {
+      anthropic_version: "bedrock-2023-05-31",
+      max_tokens: request.max_tokens || 1024,
+      system: systemMessage,
+      messages: userMessages,
+      temperature: request.temperature || 0.7
+    };
+    try {
+      const command = new InvokeModelCommand({
+        modelId,
+        contentType: "application/json",
+        accept: "application/json",
+        body: JSON.stringify(payload)
+      });
+      const response = await this.client.send(command);
+      const responseBody = JSON.parse(new TextDecoder().decode(response.body));
+      return {
+        content: responseBody.content?.[0]?.text || null,
+        usage: {
+          prompt_tokens: responseBody.usage?.input_tokens || 0,
+          completion_tokens: responseBody.usage?.output_tokens || 0,
+          total_tokens: (responseBody.usage?.input_tokens || 0) + (responseBody.usage?.output_tokens || 0)
+        },
+        provider_name: this.providerName,
+        model_name: modelId
+      };
+    } catch (e) {
+      throw new Error(`AWS Bedrock invocation failed: ${e.message}`);
+    }
+  }
+  async *chatStream(request) {
+    const res = await this.chatComplete(request);
+    if (res.content) {
+      yield res.content;
+    }
+  }
+};
+
+// src/models/gcp_vertex.ts
+import { VertexAI } from "@google-cloud/vertexai";
+var GcpVertexProvider = class extends BaseProvider {
+  client;
+  defaultModel;
+  constructor(config) {
+    super();
+    this.client = new VertexAI({ project: config.project, location: config.location });
+    this.defaultModel = config.defaultModel || "gemini-1.5-flash-preview-0409";
+  }
+  get providerName() {
+    return "gcp_vertex";
+  }
+  async chatComplete(request) {
+    const model = request.model_family === "smart" ? "gemini-1.5-pro-preview-0409" : this.defaultModel;
+    const generativeModel = this.client.getGenerativeModel({
+      model,
+      generationConfig: {
+        maxOutputTokens: request.max_tokens || 1024,
+        temperature: request.temperature || 0.7
+      }
+    });
+    const systemInstruction = request.messages.find((m) => m.role === "system")?.content || void 0;
+    const contents = request.messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    try {
+      const response = await generativeModel.generateContent({
+        contents,
+        systemInstruction: systemInstruction ? { role: "system", parts: [{ text: systemInstruction }] } : void 0
+      });
+      const responseText = response.response.candidates?.[0]?.content?.parts?.[0]?.text || null;
+      return {
+        content: responseText,
+        usage: {
+          prompt_tokens: response.response.usageMetadata?.promptTokenCount || 0,
+          completion_tokens: response.response.usageMetadata?.candidatesTokenCount || 0,
+          total_tokens: response.response.usageMetadata?.totalTokenCount || 0
+        },
+        provider_name: this.providerName,
+        model_name: model
+      };
+    } catch (e) {
+      throw new Error(`GCP Vertex invocation failed: ${e.message}`);
+    }
+  }
+  async *chatStream(request) {
+    const model = request.model_family === "smart" ? "gemini-1.5-pro-preview-0409" : this.defaultModel;
+    const generativeModel = this.client.getGenerativeModel({ model });
+    const contents = request.messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    const stream = await generativeModel.generateContentStream({ contents });
+    for await (const chunk of stream.stream) {
+      if (chunk.candidates?.[0]?.content?.parts?.[0]?.text) {
+        yield chunk.candidates[0].content.parts[0].text;
+      }
+    }
+  }
+};
+
+// src/models/azure_openai.ts
+import { OpenAIClient, AzureKeyCredential } from "@azure/openai";
+var AzureOpenAiProvider = class extends BaseProvider {
+  client;
+  deploymentName;
+  constructor(config) {
+    super();
+    this.client = new OpenAIClient(config.endpoint, new AzureKeyCredential(config.apiKey));
+    this.deploymentName = config.deploymentName || "gpt-35-turbo";
+  }
+  get providerName() {
+    return "azure_openai";
+  }
+  async chatComplete(request) {
+    try {
+      const response = await this.client.getChatCompletions(
+        this.deploymentName,
+        request.messages.map((m) => ({
+          role: m.role,
+          content: m.content
+        })),
+        {
+          maxTokens: request.max_tokens || 1024,
+          temperature: request.temperature || 0.7
+        }
+      );
+      const message = response.choices[0].message;
+      return {
+        content: message?.content || null,
+        tool_calls: message?.toolCalls ? message.toolCalls.map((tc) => ({
+          id: tc.id,
+          function: {
+            name: tc.function?.name,
+            arguments: tc.function?.arguments
+          }
+        })) : void 0,
+        usage: {
+          prompt_tokens: response.usage?.promptTokens || 0,
+          completion_tokens: response.usage?.completionTokens || 0,
+          total_tokens: response.usage?.totalTokens || 0
+        },
+        provider_name: this.providerName,
+        model_name: this.deploymentName
+      };
+    } catch (e) {
+      throw new Error(`Azure OpenAI invocation failed: ${e.message}`);
+    }
+  }
+  async *chatStream(request) {
+    const stream = await this.client.streamChatCompletions(
+      this.deploymentName,
+      request.messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      {
+        maxTokens: request.max_tokens || 1024,
+        temperature: request.temperature || 0.7
+      }
+    );
+    for await (const chunk of stream) {
+      for (const choice of chunk.choices) {
+        if (choice.delta?.content) {
+          yield choice.delta.content;
+        }
+      }
+    }
+  }
+};
 export {
   AIModelGateway,
   APIConnector,
@@ -14184,6 +14562,10 @@ export {
   AgentIterationLimitError,
   AgentPipeline,
   AgentRouter,
+  AwsBedrockProvider,
+  AwsSageMakerDeployer,
+  AzureMlDeployer,
+  AzureOpenAiProvider,
   BaseProvider,
   BaseSTTProvider,
   BaseSpeakerRecognizer,
@@ -14201,9 +14583,10 @@ export {
   DEFAULT_REDACTION_RULES,
   EchoAI,
   EchoVoice,
-  ExperimentManager,
   FileSessionStore,
   GatewayRoutingError,
+  GcpVertexManager,
+  GcpVertexProvider,
   HandoffManager,
   HuggingFaceImageGen,
   HuggingFaceTTS,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "echo-ai-sdk-ts",
-  "version": "2.5.0",
-  "description": "Echo AI SDK: Tier 4 Serverless Modality (Hugging Face TTS, Image Generation, Managed Deployments)",
+  "version": "2.6.0",
+  "description": "Echo AI SDK: Tier 5 Cloud Native (AWS Bedrock/SageMaker, GCP Vertex, Azure OpenAI/ML)",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -9,7 +9,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "build": "tsup src/index.ts --format cjs,esm --external @azure/arm-machinelearning,@azure/identity,@google-cloud/aiplatform,@google-cloud/vertexai,@aws-sdk/client-sagemaker,@aws-sdk/client-bedrock-runtime,@azure/openai",
     "dev": "tsup src/index.ts --format cjs,esm --watch --dts",
     "lint": "tsc",
     "test": "vitest run"
@@ -23,6 +23,13 @@
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "^0.80.0",
+    "@aws-sdk/client-bedrock-runtime": "^3.1019.0",
+    "@aws-sdk/client-sagemaker": "^3.1019.0",
+    "@azure/arm-machinelearning": "^3.0.0",
+    "@azure/identity": "^4.13.1",
+    "@azure/openai": "^2.0.0",
+    "@google-cloud/aiplatform": "^6.5.0",
+    "@google-cloud/vertexai": "^1.10.3",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
     "@types/node": "^20.11.24",
@@ -31,4 +38,4 @@
     "typescript": "^5.3.3",
     "vitest": "^1.3.1"
   }
-}
+}