@tool-bridge/server 0.1.1 → 0.3.0

package/dist/replicate-VICFSQ5A.js

@@ -0,0 +1,347 @@
+import {
+  createProviderPlugin,
+  guardedFetch,
+  requireApiKey,
+  upstreamError
+} from "./chunk-CSJEZHQO.js";
+import "./chunk-K7FVSFUX.js";
+import {
+  TBError,
+  external_exports
+} from "./chunk-JLTYA2B3.js";
+import "./chunk-MLKGABMK.js";
+
+// ../plugins/src/replicate/api.ts
+var SERVICE = "replicate";
+var API_BASE = "https://api.replicate.com";
+var ACCOUNT_PATH = "/v1/account";
+function text(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function compact(input) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => value !== void 0)
+  );
+}
+function required(value, field) {
+  const trimmed = text(value);
+  if (trimmed === void 0) throw new TBError("invalid_argument", `${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+  return trimmed;
+}
+function segment(value, field) {
+  return encodeURIComponent(required(value, field));
+}
+async function request(ctx, input) {
+  const url = new URL(`${API_BASE}${input.path}`);
+  for (const [key, value] of Object.entries(input.query ?? {})) {
+    if (value !== void 0 && value !== "") url.searchParams.set(key, value);
+  }
+  const headers = {
+    accept: "application/json",
+    authorization: `Bearer ${requireApiKey(ctx, SERVICE)}`,
+    ...input.headers
+  };
+  if (input.body !== void 0) headers["content-type"] = "application/json";
+  const response = await guardedFetch(url.toString(), {
+    method: input.method ?? "GET",
+    headers,
+    body: input.body === void 0 ? void 0 : JSON.stringify(input.body)
+  });
+  const raw = await response.text();
+  let payload = {};
+  let isJson = true;
+  if (raw !== "") {
+    try {
+      payload = JSON.parse(raw);
+    } catch {
+      isJson = false;
+      payload = { detail: raw };
+    }
+  }
+  if (!response.ok) {
+    const body = record(payload) ?? {};
+    const message = text(body.detail) ?? text(body.title) ?? `Replicate \u8FD4\u56DE HTTP ${response.status}`;
+    throw upstreamError(response.status, message);
+  }
+  if (!isJson) throw new TBError("unavailable", "Replicate \u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94", { retryable: true });
+  return payload;
+}
+function requireRecord(value, label) {
+  const payload = record(value);
+  if (payload === void 0) {
+    throw new TBError("unavailable", `Replicate \u7684 ${label} \u54CD\u5E94\u4E0D\u662F\u5BF9\u8C61`, { retryable: true });
+  }
+  return payload;
+}
+function pageOf(value, field) {
+  const payload = requireRecord(value, field);
+  if (!Array.isArray(payload.results)) {
+    throw new TBError("unavailable", `Replicate \u7684 ${field} \u54CD\u5E94\u7F3A\u5C11 results \u6570\u7EC4`, { retryable: true });
+  }
+  return {
+    [field]: payload.results,
+    next: typeof payload.next === "string" ? payload.next : null,
+    previous: typeof payload.previous === "string" ? payload.previous : null
+  };
+}
+function wrap(value, field) {
+  return { [field]: requireRecord(value, field) };
+}
+async function getAccount(_input, ctx) {
+  return wrap(await request(ctx, { path: ACCOUNT_PATH }), "account");
+}
+async function listModels(input, ctx) {
+  const payload = await request(ctx, {
+    path: "/v1/models",
+    query: compact({
+      sort_by: text(input.sortBy),
+      sort_direction: text(input.sortDirection)
+    })
+  });
+  return pageOf(payload, "models");
+}
+async function getModel(input, ctx) {
+  const path = `/v1/models/${segment(input.owner, "owner")}/${segment(input.model, "model")}`;
+  return wrap(await request(ctx, { path }), "model");
+}
+async function listModelVersions(input, ctx) {
+  const path = `/v1/models/${segment(input.owner, "owner")}/${segment(input.model, "model")}/versions`;
+  return pageOf(await request(ctx, { path }), "versions");
+}
+async function getModelVersion(input, ctx) {
+  const path = `/v1/models/${segment(input.owner, "owner")}/${segment(input.model, "model")}/versions/${segment(input.versionId, "versionId")}`;
+  return wrap(await request(ctx, { path }), "version");
+}
+async function listCollections(_input, ctx) {
+  return pageOf(await request(ctx, { path: "/v1/collections" }), "collections");
+}
+async function getCollection(input, ctx) {
+  const path = `/v1/collections/${segment(input.collectionSlug, "collectionSlug")}`;
+  return wrap(await request(ctx, { path }), "collection");
+}
+async function createPrediction(input, ctx) {
+  const headers = compact({
+    "Prefer": input.waitSeconds === void 0 ? void 0 : `wait=${input.waitSeconds}`,
+    "Cancel-After": text(input.cancelAfter)
+  });
+  const payload = await request(ctx, {
+    method: "POST",
+    path: "/v1/predictions",
+    headers,
+    body: compact({
+      version: required(input.version, "version"),
+      input: record(input.input) ?? {},
+      webhook: text(input.webhook),
+      webhook_events_filter: input.webhookEventsFilter
+    })
+  });
+  return wrap(payload, "prediction");
+}
+async function getPrediction(input, ctx) {
+  const path = `/v1/predictions/${segment(input.predictionId, "predictionId")}`;
+  return wrap(await request(ctx, { path }), "prediction");
+}
+async function listPredictions(input, ctx) {
+  const payload = await request(ctx, {
+    path: "/v1/predictions",
+    query: compact({
+      created_after: text(input.createdAfter),
+      created_before: text(input.createdBefore),
+      source: text(input.source)
+    })
+  });
+  return pageOf(payload, "predictions");
+}
+async function cancelPrediction(input, ctx) {
+  const payload = await request(ctx, {
+    method: "POST",
+    path: `/v1/predictions/${segment(input.predictionId, "predictionId")}/cancel`,
+    // 上游发的是空 JSON 对象(不是无 body)—— 少了它 content-type 也不会带上。
+    body: {}
+  });
+  return wrap(payload, "prediction");
+}
+
+// ../plugins/src/replicate/schema.ts
+var getAccountInput = external_exports.strictObject({}).describe("No input parameters are required.");
+var getAccountOutput = external_exports.looseObject({
+  account: external_exports.looseObject({}).describe("A Replicate API object.")
+}).describe("The authenticated Replicate account response.");
+var listModelsInput = external_exports.strictObject({
+  sortBy: external_exports.enum(["model_created_at", "latest_version_created_at"]).describe("The field used to sort public Replicate models.").optional(),
+  sortDirection: external_exports.enum(["asc", "desc"]).describe("The sort direction for Replicate model results.").optional()
+}).describe("Input for listing public Replicate models.");
+var listModelsOutput = external_exports.looseObject({
+  models: external_exports.array(external_exports.looseObject({}).describe("A Replicate API object.")).describe("The Replicate models returned for this page."),
+  next: external_exports.url().describe("A Replicate pagination URL.").nullable(),
+  previous: external_exports.url().describe("A Replicate pagination URL.").nullable()
+}).describe("A paginated list of Replicate models.");
+var getModelInput = external_exports.strictObject({
+  owner: external_exports.string().min(1).describe("The Replicate model owner username or organization slug.").optional(),
+  model: external_exports.string().min(1).describe("The Replicate model name slug.").optional()
+}).describe("Input for selecting a Replicate model.");
+var getModelOutput = external_exports.looseObject({
+  model: external_exports.looseObject({}).describe("A Replicate API object.")
+}).describe("A Replicate model response.");
+var listModelVersionsInput = external_exports.strictObject({
+  owner: external_exports.string().min(1).describe("The Replicate model owner username or organization slug.").optional(),
+  model: external_exports.string().min(1).describe("The Replicate model name slug.").optional()
+}).describe("Input for selecting a Replicate model.");
+var listModelVersionsOutput = external_exports.looseObject({
+  versions: external_exports.array(external_exports.looseObject({}).describe("A Replicate API object.")).describe("The model versions returned for this page."),
+  next: external_exports.url().describe("A Replicate pagination URL.").nullable(),
+  previous: external_exports.url().describe("A Replicate pagination URL.").nullable()
+}).describe("A paginated list of Replicate model versions.");
+var getModelVersionInput = external_exports.strictObject({
+  owner: external_exports.string().min(1).describe("The Replicate model owner username or organization slug.").optional(),
+  model: external_exports.string().min(1).describe("The Replicate model name slug.").optional(),
+  versionId: external_exports.string().min(1).describe("The Replicate model version identifier.").optional()
+}).describe("Input for selecting a Replicate model version.");
+var getModelVersionOutput = external_exports.looseObject({
+  version: external_exports.looseObject({}).describe("A Replicate API object.")
+}).describe("A Replicate model version response.");
+var listCollectionsInput = external_exports.strictObject({}).describe("No input parameters are required.");
+var listCollectionsOutput = external_exports.looseObject({
+  collections: external_exports.array(external_exports.looseObject({}).describe("A Replicate API object.")).describe("The Replicate collections returned for this page."),
+  next: external_exports.url().describe("A Replicate pagination URL.").nullable(),
+  previous: external_exports.url().describe("A Replicate pagination URL.").nullable()
+}).describe("A paginated list of Replicate collections.");
+var getCollectionInput = external_exports.strictObject({
+  collectionSlug: external_exports.string().min(1).describe("The Replicate collection slug.").optional()
+}).describe("Input for selecting a Replicate collection.");
+var getCollectionOutput = external_exports.looseObject({
+  collection: external_exports.looseObject({}).describe("A Replicate API object.")
+}).describe("A Replicate collection response.");
+var createPredictionInput = external_exports.strictObject({
+  version: external_exports.string().min(1).describe("The Replicate model identifier, model version identifier, or owner/model:version reference."),
+  input: external_exports.looseObject({}).describe("A JSON-serializable model input object."),
+  waitSeconds: external_exports.int().min(1).max(60).describe("Seconds to wait synchronously for prediction output.").optional(),
+  cancelAfter: external_exports.string().min(1).describe("Maximum prediction runtime before Replicate cancels it, such as 30s, 5m, or 1h30m.").optional(),
+  webhook: external_exports.url().describe("An HTTPS webhook URL for Replicate prediction events.").optional(),
+  webhookEventsFilter: external_exports.array(external_exports.enum(["start", "output", "logs", "completed"]).describe("One Replicate webhook event filter.")).min(1).describe("The Replicate prediction event types that should trigger the webhook.").optional()
+}).describe("Input for creating a Replicate prediction from a model or model version.");
+var createPredictionOutput = external_exports.looseObject({
+  prediction: external_exports.looseObject({}).describe("A Replicate API object.")
+}).describe("A Replicate prediction response.");
+var getPredictionInput = external_exports.strictObject({
+  predictionId: external_exports.string().min(1).describe("The Replicate prediction identifier.").optional()
+}).describe("Input for selecting a Replicate prediction.");
+var getPredictionOutput = external_exports.looseObject({
+  prediction: external_exports.looseObject({}).describe("A Replicate API object.")
+}).describe("A Replicate prediction response.");
+var listPredictionsInput = external_exports.strictObject({
+  createdAfter: external_exports.iso.datetime({ offset: true }).describe("Include predictions created at or after this ISO 8601 timestamp.").optional(),
+  createdBefore: external_exports.iso.datetime({ offset: true }).describe("Include predictions created before this ISO 8601 timestamp.").optional(),
+  source: external_exports.literal("web").describe("Filter predictions to those created from the Replicate website.").optional()
+}).describe("Input for filtering Replicate predictions.");
+var listPredictionsOutput = external_exports.looseObject({
+  predictions: external_exports.array(external_exports.looseObject({}).describe("A Replicate API object.")).describe("The Replicate predictions returned for this page."),
+  next: external_exports.url().describe("A Replicate pagination URL.").nullable(),
+  previous: external_exports.url().describe("A Replicate pagination URL.").nullable()
+}).describe("A paginated list of Replicate predictions.");
+var cancelPredictionInput = external_exports.strictObject({
+  predictionId: external_exports.string().min(1).describe("The Replicate prediction identifier.").optional()
+}).describe("Input for selecting a Replicate prediction.");
+var cancelPredictionOutput = external_exports.looseObject({
+  prediction: external_exports.looseObject({}).describe("A Replicate API object.")
+}).describe("A Replicate prediction response after cancellation.");
+var replicateActions = {
+  get_account: {
+    description: "Retrieve the authenticated Replicate account for the connected API token.",
+    effect: "read",
+    inputSchema: getAccountInput,
+    outputSchema: external_exports.toJSONSchema(getAccountOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_models: {
+    description: "List public Replicate models with optional official sorting parameters.",
+    effect: "read",
+    inputSchema: listModelsInput,
+    outputSchema: external_exports.toJSONSchema(listModelsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_model: {
+    description: "Retrieve one Replicate model by owner and model slug.",
+    effect: "read",
+    inputSchema: getModelInput,
+    outputSchema: external_exports.toJSONSchema(getModelOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_model_versions: {
+    description: "List versions for one Replicate model.",
+    effect: "read",
+    inputSchema: listModelVersionsInput,
+    outputSchema: external_exports.toJSONSchema(listModelVersionsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_model_version: {
+    description: "Retrieve one Replicate model version by owner, model, and version ID.",
+    effect: "read",
+    inputSchema: getModelVersionInput,
+    outputSchema: external_exports.toJSONSchema(getModelVersionOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_collections: {
+    description: "List public Replicate model collections.",
+    effect: "read",
+    inputSchema: listCollectionsInput,
+    outputSchema: external_exports.toJSONSchema(listCollectionsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_collection: {
+    description: "Retrieve one Replicate collection by slug.",
+    effect: "read",
+    inputSchema: getCollectionInput,
+    outputSchema: external_exports.toJSONSchema(getCollectionOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_prediction: {
+    description: "Create a Replicate prediction using JSON model input and optional synchronous wait headers.",
+    effect: "write",
+    inputSchema: createPredictionInput,
+    outputSchema: external_exports.toJSONSchema(createPredictionOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_prediction: {
+    description: "Retrieve the current state and output of a Replicate prediction.",
+    effect: "read",
+    inputSchema: getPredictionInput,
+    outputSchema: external_exports.toJSONSchema(getPredictionOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_predictions: {
+    description: "List Replicate predictions for the authenticated account.",
+    effect: "read",
+    inputSchema: listPredictionsInput,
+    outputSchema: external_exports.toJSONSchema(listPredictionsOutput, { io: "output", unrepresentable: "any" })
+  },
+  cancel_prediction: {
+    description: "Cancel a running Replicate prediction by prediction ID.",
+    effect: "destructive",
+    inputSchema: cancelPredictionInput,
+    outputSchema: external_exports.toJSONSchema(cancelPredictionOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/replicate/index.ts
+function createReplicatePlugin() {
+  return createProviderPlugin({
+    description: "Replicate",
+    actions: replicateActions,
+    credentialProbe: "get_account",
+    handlers: {
+      get_account: getAccount,
+      list_models: listModels,
+      get_model: getModel,
+      list_model_versions: listModelVersions,
+      get_model_version: getModelVersion,
+      list_collections: listCollections,
+      get_collection: getCollection,
+      create_prediction: createPrediction,
+      get_prediction: getPrediction,
+      list_predictions: listPredictions,
+      cancel_prediction: cancelPrediction
+    }
+  });
+}
+var replicate_default = createReplicatePlugin();
+export {
+  createReplicatePlugin,
+  replicate_default as default
+};

package/dist/resend-3E76WK3O.js

@@ -0,0 +1,100 @@
+import {
+  createProviderPlugin,
+  guardedFetch,
+  requireApiKey,
+  upstreamError
+} from "./chunk-CSJEZHQO.js";
+import "./chunk-K7FVSFUX.js";
+import {
+  TBError,
+  external_exports
+} from "./chunk-JLTYA2B3.js";
+import "./chunk-MLKGABMK.js";
+
+// ../plugins/src/resend/schema.handwritten.ts
+var sendEmailInput = external_exports.strictObject({
+  from: external_exports.string().min(1).describe("The sender email address."),
+  to: external_exports.string().min(1).describe("The recipient email address."),
+  subject: external_exports.string().min(1).describe("The email subject line."),
+  html: external_exports.string().describe("The HTML body of the email. Provide at least one of html or text.").optional(),
+  text: external_exports.string().describe("The plain text body of the email. Provide at least one of html or text.").optional()
+}).refine(
+  (input) => input.html !== void 0 || input.text !== void 0,
+  { message: "at least one of html or text is required", path: ["html"] }
+).describe("The input payload for sending a Resend email.");
+var sendEmailOutput = external_exports.strictObject({
+  emailId: external_exports.string().describe("The unique identifier of the sent email.").optional()
+}).describe("The output payload for this action.");
+
+// ../plugins/src/resend/schema.ts
+var resendActions = {
+  send_email: {
+    description: "Send an email with Resend.",
+    effect: "write",
+    inputSchema: sendEmailInput,
+    outputSchema: external_exports.toJSONSchema(sendEmailOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/resend/api.ts
+var SERVICE = "resend";
+var API_BASE = "https://api.resend.com";
+var AUTH_ERROR_NAMES = /* @__PURE__ */ new Set(["invalid_api_key", "missing_api_key"]);
+async function readPayload(response) {
+  const text2 = await response.text().catch(() => "");
+  if (text2 === "") return {};
+  try {
+    const parsed = JSON.parse(text2);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return { message: text2 };
+  }
+}
+function text(value) {
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function resendError(status, payload) {
+  const name = text(payload.name) ?? text(payload.error) ?? "provider_error";
+  const message = text(payload.message) ?? text(payload.error_description) ?? `Resend \u8FD4\u56DE HTTP ${status}`;
+  if (AUTH_ERROR_NAMES.has(name)) {
+    return new TBError("permission_denied", message, { httpStatus: 401 });
+  }
+  return upstreamError(status, message);
+}
+async function sendEmail(input, ctx) {
+  const response = await guardedFetch(`${API_BASE}/emails`, {
+    method: "POST",
+    headers: {
+      "authorization": `Bearer ${requireApiKey(ctx, SERVICE)}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      from: input.from,
+      to: input.to,
+      subject: input.subject,
+      ...input.html === void 0 ? {} : { html: input.html },
+      ...input.text === void 0 ? {} : { text: input.text }
+    })
+  });
+  const payload = await readPayload(response);
+  if (!response.ok) throw resendError(response.status, payload);
+  const emailId = text(payload.id);
+  if (emailId === void 0) {
+    throw new TBError("unavailable", "Resend \u7684\u6210\u529F\u54CD\u5E94\u91CC\u6CA1\u6709 email id", { retryable: true });
+  }
+  return { emailId };
+}
+
+// ../plugins/src/resend/index.ts
+function createResendPlugin() {
+  return createProviderPlugin({
+    description: "Resend",
+    actions: resendActions,
+    handlers: { send_email: sendEmail }
+  });
+}
+var resend_default = createResendPlugin();
+export {
+  createResendPlugin,
+  resend_default as default
+};