import llamaCppPlugin from "./index.js";

import {

DEFAULT_LLAMA_CPP_EMBEDDING_MODEL,

createLlamaCppEmbeddingProvider,

createLlamaCppMemoryEmbeddingProvider,

formatLlamaCppSetupError,

llamaCppEmbeddingProviderAdapter,

});

const abortController = new AbortController();

const provider = await createLlamaCppEmbeddingProvider(

{

config: {},

provider: "local",

model: "text-embedding-3-small",

},

{ nodeLlamaCppImportUrl: "file:///plugin/node-llama-cpp.js" },

);

const result = await llamaCppEmbeddingProviderAdapter.create({

config: {},

provider: "local",

model: "text-embedding-3-small",

});

const provider = result.provider;

expect(provider).not.toBeNull();

if (!provider) {

throw new Error("expected llama.cpp provider");

}

await expect(provider.embed("hello")).resolves.toEqual([0.6, 0.8]);

await expect(

},

},

{

nodeLlamaCppImportUrl: "file:///plugin/node-llama-cpp.js",

nodeLlamaCppImportUrl: expect.stringContaining("node-llama-cpp"),

},

);

const workerProvider =

};

}

export async function createLlamaCppEmbeddingProvider(

options: EmbeddingProviderCreateOptions,

runtimeOptions: LlamaCppEmbeddingProviderRuntimeOptions = {},

): Promise<EmbeddingProvider> {

const result = await createLlamaCppEmbeddingProviderResult(options, runtimeOptions);

if (!result.provider) {

throw new Error("llama.cpp local embedding provider was unavailable");

}

return result.provider;

}

export async function createLlamaCppMemoryEmbeddingProvider(

options: MemoryEmbeddingProviderCreateOptions,

runtimeOptions: LlamaCppEmbeddingProviderRuntimeOptions = {},

type MSTeamsSsoFetch,

handleSigninTokenExchangeInvoke,

handleSigninVerifyStateInvoke,

parseSigninTokenExchangeValue,

parseSigninVerifyStateValue,

} from "./sso.js";

function createMemorySsoTokenStore(): MSTeamsSsoTokenStore {

return { fetchImpl, calls };

}

describe("msteams signin invoke value parsers", () => {

it("parses signin/tokenExchange values", () => {

expect(

parseSigninTokenExchangeValue({

id: "flow-1",

connectionName: "Graph",

token: "eyJ...",

}),

).toEqual({ id: "flow-1", connectionName: "Graph", token: "eyJ..." });

});

it("rejects non-object signin/tokenExchange values", () => {

expect(parseSigninTokenExchangeValue(null)).toBeNull();

expect(parseSigninTokenExchangeValue("nope")).toBeNull();

});

it("parses signin/verifyState values", () => {

expect(parseSigninVerifyStateValue({ state: "123456" })).toEqual({ state: "123456" });

expect(parseSigninVerifyStateValue({})).toEqual({ state: undefined });

expect(parseSigninVerifyStateValue(null)).toBeNull();

});

});

describe("handleSigninTokenExchangeInvoke", () => {

it("exchanges the Teams token and persists the result", async () => {

const { fetchImpl, calls } = createFakeFetch([

state?: string;

};

/**

* Extract and validate the `signin/tokenExchange` activity value. Teams

* delivers `{ id, connectionName, token }`; any field may be missing on

* malformed invocations, so callers should check the parsed result.

*/

export function parseSigninTokenExchangeValue(value: unknown): SigninTokenExchangeValue | null {

if (!value || typeof value !== "object") {

return null;

}

const obj = value as Record<string, unknown>;

const id = typeof obj.id === "string" ? obj.id : undefined;

const connectionName = typeof obj.connectionName === "string" ? obj.connectionName : undefined;

const token = typeof obj.token === "string" ? obj.token : undefined;

return { id, connectionName, token };

}

/** Extract the `signin/verifyState` activity value `{ state }`. */

export function parseSigninVerifyStateValue(value: unknown): SigninVerifyStateValue | null {

if (!value || typeof value !== "object") {

return null;

}

const obj = value as Record<string, unknown>;

const state = typeof obj.state === "string" ? obj.state : undefined;

return { state };

}

type UserTokenServiceCallParams = {

baseUrl: string;

path: string;

}));

import {

closeAllQaWebSessions,

closeQaWebSessions,

qaWebEvaluate,

qaWebOpenPage,

});

const snapshot = await qaWebSnapshot({ pageId: opened.pageId, maxChars: 5 });

const evaluated = await qaWebEvaluate({ pageId: opened.pageId, expression: "'ok'" });

await closeAllQaWebSessions();

await closeQaWebSessions();

const launchOptions = requireLaunchOptions();

expect(launchOptions?.channel).toBe("chrome");

);

const snapshot = await qaWebSnapshot({ pageId: second.pageId });

expect(snapshot.text).toBe("hello from body");

await closeAllQaWebSessions();

await closeQaWebSessions();

});

it("caps oversized web runtime timeouts", async () => {

expression: "'ok'",

timeoutMs: Number.MAX_SAFE_INTEGER,

});

await closeAllQaWebSessions();

await closeQaWebSessions();

expect(goto).toHaveBeenCalledWith("http://127.0.0.1:3000/chat", {

waitUntil: "domcontentloaded",

await session.browser.close().catch(() => {});

}

}

export async function closeAllQaWebSessions(): Promise<void> {

await closeQaWebSessions();

}