function with unknown parameter is not assignable to function with string parameter

The error is a valid one; if you have interfaces A and B extends A, then that if I want an A it's okay for you to hand me a B. But with your definitions, that breaks:

function callBaseProtocol(bp: BaseProtocol) {
    return bp.action(12345);
}

function callAppProtocol(ap: AppProtocol) {
    callBaseProtocol(ap); // oops!
}

The function callBaseProtocol() is not in error. The definition of BaseProtocol says that every string-valued key is a function which takes a value of type unknown and returns a Promise<unknown>. Specifically, the action property of a BaseProtocol must be a function that accepts a value of type unknown. You can therefore pass it a number.

The function callAppProtocol() is also not in error. Here we are calling callBaseProtocol() and passing it an AppProtocol. That is supposed to be acceptable because AppProtocol extends BaseProtocol.

But if an AppProtocol has an action property that expects a string and calls some string-specific method on it like x => x.toUpperCase(), this will explode. The error is that AppProtocol does not, in fact, properly extend BaseProtocol.

This possibly surprising phenomenon is known as parameter contravariance, where if X is a subtype of Y, then the function (y: Y)=>any is a subtype of (x: X)=>any, and not vice versa. The direction of subtyping goes the other way for function parameters, and that "goes the other way" is what "contravariance" means.

This behavior was introduced in TypeScript via the --strictFunctionTypes compiler option, and is a type safety improvement.

So how can you deal with this? Assuming you want increased type safety and not reduced type safety (you mention not wanting to use any), then perhaps your BaseProtocol isn't really properly defined. Maybe instead of having a string index signature and passing around unknowns, it should be a generic interface that represents a more complex relationship between input and output. Perhaps something like this:

export type BaseProtocol<T> = {
    [K in keyof T]: (payload: T[K]) => Promise<T[K]>;
}

This is saying that a BaseProtocol depends on another type T, and that a BaseProtocol<T> has a method for every property of T, which takes a parameter of the type of that property value, and returns a Promise of that type.

And then AppProtocol can be simply defined as:

export interface AppProtocol extends BaseProtocol<{ action: string }> {
}

This solves the problem from before, since the compiler will not allow you to call a BaseProtocol<T>'s action() method on a number argument unless it knows that T has an action property of type number:

function callBaseProtocol<T>(bp: BaseProtocol<T>) {
    return bp.action(12345); // error! might not have an action
}

There's also a hybrid approach that doesn't assume the return value of each function is a promise of the same type as its input:

export type BaseProtocol<T> = {
    [K in keyof T]: (payload: T[K]) => unknown;
}

export interface AppProtocol extends BaseProtocol<{ action: string }> {
    action(x: string): Promise<string>;
}

Okay, hope that helps; good luck!

Playground link to code