expect(init?.headers?.["User-Agent"]).toMatch(/^teams\.ts\[apps\]\/.+ OpenClaw\/.+$/);

}

function bodyOnlyErrorResponse(body: string, status = 500): Response {

return {

ok: false,

status,

headers: new Headers(),

body: new Response(body).body,

} as unknown as Response;

}

describe("graph upload helpers", () => {

const tokenProvider = {

getAccessToken: vi.fn(async () => "graph-token"),

}),

).rejects.toThrow("SharePoint upload response missing required fields");

});

it("bounds upload error bodies without requiring response.text()", async () => {

const fetchFn = vi.fn(async () =>

bodyOnlyErrorResponse(`${"upload-denied ".repeat(4096)}tail-marker`, 413),

);

let error: unknown;

try {

await uploadToSharePoint({

buffer: Buffer.from("world"),

filename: "large.txt",

siteId: "site-123",

tokenProvider,

fetchFn: fetchFn as unknown as typeof fetch,

});

} catch (caught) {

error = caught;

}

expect(error).toBeInstanceOf(Error);

const message = (error as Error).message;

expect(message).toContain("SharePoint upload failed (413): upload-denied");

expect(message).not.toContain("tail-marker");

expect(message.length).toBeLessThan(700);

});

});

describe("resolveGraphChatId", () => {

*/

import type { MSTeamsAccessTokenProvider } from "./attachments/types.js";

import { createMSTeamsHttpError } from "./http-error.js";

import { buildUserAgent } from "./user-agent.js";

const GRAPH_ROOT = "https://graph.microsoft.com/v1.0";

});

if (!res.ok) {

const body = await res.text().catch(() => "");

throw new Error(`OneDrive upload failed: ${res.status} ${res.statusText} - ${body}`);

throw await createMSTeamsHttpError(res, "OneDrive upload failed");

}

const data = (await res.json()) as {

});

if (!res.ok) {

const body = await res.text().catch(() => "");

throw new Error(`Create sharing link failed: ${res.status} ${res.statusText} - ${body}`);

throw await createMSTeamsHttpError(res, "Create sharing link failed");

}

const data = (await res.json()) as {

);

if (!res.ok) {

const body = await res.text().catch(() => "");

throw new Error(`SharePoint upload failed: ${res.status} ${res.statusText} - ${body}`);

throw await createMSTeamsHttpError(res, "SharePoint upload failed");

}

const data = (await res.json()) as {

);

if (!res.ok) {

const body = await res.text().catch(() => "");

throw new Error(`Get driveItem properties failed: ${res.status} ${res.statusText} - ${body}`);

throw await createMSTeamsHttpError(res, "Get driveItem properties failed");

}

const data = (await res.json()) as {

});

if (!res.ok) {

const body = await res.text().catch(() => "");

throw new Error(`Get chat members failed: ${res.status} ${res.statusText} - ${body}`);

throw await createMSTeamsHttpError(res, "Get chat members failed");

}

const data = (await res.json()) as {

);

if (!res.ok) {

const respBody = await res.text().catch(() => "");

throw new Error(

`Create SharePoint sharing link failed: ${res.status} ${res.statusText} - ${respBody}`,

);

throw await createMSTeamsHttpError(res, "Create SharePoint sharing link failed");

}

const data = (await res.json()) as {

const GRAPH_BETA = "https://graph.microsoft.com/beta";

const NULL_BODY_STATUSES = new Set([101, 204, 205, 304]);

import { createMSTeamsTokenProvider, loadMSTeamsSdkWithAuth } from "./sdk.js";

import { createMSTeamsHttpError } from "./http-error.js";

import { readAccessToken } from "./token-response.js";

import { resolveDelegatedAccessToken, resolveMSTeamsCredentials } from "./token.js";

import { buildUserAgent } from "./user-agent.js";

});

try {

if (!response.ok) {

const text = await response.text().catch(() => "");

throw new Error(

`${params.errorPrefix ?? "Graph"} ${params.path} failed (${response.status}): ${text || "unknown error"}`,

throw await createMSTeamsHttpError(

response,

`${params.errorPrefix ?? "Graph"} ${params.path} failed`,

);

}

const body = NULL_BODY_STATUSES.has(response.status) ? null : await response.arrayBuffer();

});

try {

if (!response.ok) {

const text = await response.text().catch(() => "");

throw new Error(

`Graph ${params.url} failed (${response.status}): ${text || "unknown error"}`,

);

throw await createMSTeamsHttpError(response, `Graph ${params.url} failed`);

}

return await readProviderJsonResponse<T>(response, `Graph ${params.url} failed`);

} finally {

import { describe, expect, it } from "vitest";

import { createMSTeamsHttpError, readMSTeamsHttpErrorDetail } from "./http-error.js";

function bodyOnlyErrorResponse(body: string, status = 429): Response {

return {

ok: false,

status,

headers: new Headers(),

body: new Response(body).body,

} as unknown as Response;

}

describe("msteams http errors", () => {

it("creates bounded provider errors without relying on response.text()", async () => {

const error = await createMSTeamsHttpError(

bodyOnlyErrorResponse(`${"x".repeat(24 * 1024)}tail-marker`),

"Teams request failed",

);

expect(error.message).toContain("Teams request failed (429):");

expect(error.message).not.toContain("tail-marker");

expect(error.message.length).toBeLessThan(700);

expect((error as { statusCode?: number }).statusCode).toBe(429);

});

it("returns a bounded response detail for non-throwing callers", async () => {

const detail = await readMSTeamsHttpErrorDetail(

bodyOnlyErrorResponse(`${"denied ".repeat(4096)}tail-marker`, 403),

"HTTP 403",

);

expect(detail).toContain("denied");

expect(detail).not.toContain("tail-marker");

expect(detail.length).toBeLessThan(700);

});

});

import {

createProviderHttpError,

extractProviderErrorDetail,

} from "openclaw/plugin-sdk/provider-http";

export async function createMSTeamsHttpError(

response: Response,

label: string,

options?: { statusPrefix?: string },

): Promise<Error> {

return await createProviderHttpError(response, label, options);

}

export async function readMSTeamsHttpErrorDetail(

response: Response,

fallback: string,

): Promise<string> {

return (await extractProviderErrorDetail(response).catch(() => undefined)) ?? fallback;

}

status: number;

body: unknown;

};

return {

ok: response.ok,

const responseBody = response.body;

const isTextBody = typeof responseBody === "string";

return new Response(isTextBody ? responseBody : JSON.stringify(responseBody ?? ""), {

status: response.status,

json: async () => response.body,

text: async () =>

typeof response.body === "string" ? response.body : JSON.stringify(response.body ?? ""),

};

headers: { "content-type": isTextBody ? "text/plain" : "application/json" },

});

};

return { fetchImpl, calls };

}

buildMSTeamsTokenEndpoint,

type MSTeamsDelegatedTokens,

} from "./oauth.shared.js";

import { createMSTeamsHttpError } from "./http-error.js";

/** Five-minute buffer subtracted from token expiry to avoid edge-case clock drift. */

const EXPIRY_BUFFER_MS = 5 * 60 * 1000;

try {

if (!response.ok) {

const errorText = await response.text();

throw new Error(`MSTeams ${params.failureLabel} failed (${response.status}): ${errorText}`);

throw await createMSTeamsHttpError(response, `MSTeams ${params.failureLabel} failed`);

}

return await readProviderJsonResponse<MSTeamsTokenResponse>(

response,

tryNormalizeBotFrameworkServiceUrl,

} from "./bot-framework-service-url.js";

import { formatUnknownError } from "./errors.js";

import { createMSTeamsHttpError } from "./http-error.js";

import type { MSTeamsAdapter } from "./messenger.js";

import type { MSTeamsCredentials, MSTeamsFederatedCredentials } from "./token.js";

import { buildUserAgent } from "./user-agent.js";

try {

if (!response.ok) {

const body = await response.text().catch(() => "");

throw Object.assign(new Error(`updateActivity failed: HTTP ${response.status} ${body}`), {

statusCode: response.status,

throw await createMSTeamsHttpError(response, "updateActivity failed", {

statusPrefix: "HTTP ",

});

}

try {

if (!response.ok) {

const body = await response.text().catch(() => "");

throw Object.assign(new Error(`deleteActivity failed: HTTP ${response.status} ${body}`), {

statusCode: response.status,

throw await createMSTeamsHttpError(response, "deleteActivity failed", {

statusPrefix: "HTTP ",

});

}

} finally {

*/

import type { MSTeamsAccessTokenProvider } from "./attachments/types.js";

import { readMSTeamsHttpErrorDetail } from "./http-error.js";

import type { MSTeamsSsoTokenStore } from "./sso-token-store.js";

import { buildUserAgent } from "./user-agent.js";

export type MSTeamsSsoFetch = (

input: string,

init?: {

method?: string;

headers?: Record<string, string>;

body?: string;

},

) => Promise<{

ok: boolean;

status: number;

json(): Promise<unknown>;

text(): Promise<string>;

}>;

init?: RequestInit,

) => Promise<Response>;

export type MSTeamsSsoDeps = {

tokenProvider: MSTeamsAccessTokenProvider;

body: params.body === undefined ? undefined : JSON.stringify(params.body),

});

if (!response.ok) {

const text = await response.text().catch(() => "");

return { error: text || `HTTP ${response.status}`, status: response.status };

const error = await readMSTeamsHttpErrorDetail(response, `HTTP ${response.status}`);

return { error, status: response.status };

}

let parsed: unknown;

try {

expect(extractProviderRequestId(response)).toBe("fallback_req");

});

it("preserves OAuth error descriptions as actionable details", async () => {

const response = new Response(

JSON.stringify({

error: "invalid_request",

error_description: "AADSTS7000215: Invalid client secret provided.",

}),

{ status: 400 },

);

await expect(assertOkOrThrowProviderError(response, "OAuth token exchange failed")).rejects

.toThrow(

"OAuth token exchange failed (400): AADSTS7000215: Invalid client secret provided. [code=invalid_request]",

);

});

it("keeps HTTP status metadata when error body reads fail", async () => {

const response = {

ok: false,

status: 503,

headers: new Headers(),

body: {

getReader: () => ({

read: async () => {

throw new Error("broken response stream");

},

cancel: async () => undefined,

}),

},

} as unknown as Response;

await expect(assertOkOrThrowProviderError(response, "Provider API error")).rejects

.toMatchObject({

name: "ProviderHttpError",

status: 503,

statusCode: 503,

message: "Provider API error (503)",

} satisfies Partial<ProviderHttpError>);

});

it("attaches structured provider error metadata", async () => {

const response = new Response(

JSON.stringify({